learning-hours/db-subclass-to-dto
1
0
Fork 0
Code Actions Projects Activity

em 04: codegen — generate the refactoring, round-trip check, unified-diff preview

Browse Source 
RefactoringGenerator emits the new method (promoted signature, parameter
names = source symbol names) plus the rewritten call site for every
em 02/03 bucket shape (return slot declared inside/outside, tuple
deconstruction, ref write-back, return-call when the selection ends a
non-void method) and refuses loudly where v1 cannot be sound (composite
trailing return, return not ending the method).

The transformed tree must compile with zero diagnostics (the yak's
round-trip check, enforced in both the CLI and the tests).

Findings that shaped the implementation, all enforced by tests:
- NormalizeWhitespace on the WHOLE root corrupts doc-comment trivia so
  Roslyn's XML-doc writer fails with CS1569 ('count (-3) must be
  non-negative') — and it would reformat the entire file, killing the
  diff. Only generated nodes are normalized; original trivia is kept and
  indentation/end-of-line is grafted onto the inserted statements/method.
- ParseTypeName("void") yields a node rejected as a method return type
  (CS1547) — a void signature must be PredefinedType(Token(VoidKeyword)).
- NormalizeWhitespace drops the space after the contextual keyword 'var'
  before '(' — the parsed 'var (x, y) = ...' deconstruction skeleton is
  used verbatim; builder-made statements are normalized.
- The new method is normalized inside a throwaway class wrapper: the
  normalizer computes indentation from nesting depth, and a bare method
  has none.

v1 decision: print a unified-diff PREVIEW to stdout (hand-rolled LCS
unified diff), never an in-place rewrite. Also fixes the hunk header
off-by-one from the phantom trailing empty line of Split('\n').
This commit is contained in:
mostalive
2026-09-12 21:15:28 +01:00
parent 49a5633a7d
commit cdadafe676
6 changed files with 892 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/ExtractMethod/Tooling/RefactoringGenerator.cs
+399
View File
@@ -0,0 +1,399 @@
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace ExtractMethod.Tooling;
/// <summary>
/// The generated extract-method refactoring (yak em 04 codegen): the NEW
/// method (the em 03 promoted signature; parameter names come straight from
/// the source symbols), the CALL STATEMENTS that replace the selection in the
/// enclosing method, and the fully transformed syntax tree.
/// </summary>
/// <param name="NewMethod">The extracted method, ready to be read. Built
/// with SyntaxFactory and NORMALIZED (whitespace) before insertion, so its
/// text is the readable shape that lands in the file — not the trivia-less
/// builder output.</param>
/// <param name="CallStatements">The statement(s) that replace the selected
/// run at the call site (one statement, or a capture + destructure pair for
/// a mixed tuple return), normalized like <see cref="NewMethod"/>.</param>
/// <param name="TransformedTree">The whole input tree with the selection
/// moved out and the new method added next to the enclosing one — the
/// round-trip check compiles exactly this tree.</param>
public sealed record Refactoring(
MethodDeclarationSyntax NewMethod,
IReadOnlyList<StatementSyntax> CallStatements,
SyntaxTree TransformedTree)
{
public string TransformedText => TransformedTree.ToString();
}
/// <summary>
/// Emits the refactoring behind the em 03 suggestion.
///
/// WHY no identifier rewriting at all: the suggested parameter names ARE the
/// source variable names (em 02/03 promotion), so the moved statements bind
/// unchanged — every local/parameter read inside the selection is a parameter
/// of the new method, every variable declared inside moves with the body, and
/// the remaining reads are type members visible from the same class
/// (the new method is inserted into the SAME containing type). This is the
/// property the resolver (one method body, whole statements) and the
/// classifier (params bucket = exactly the local/parameter reads) jointly
/// guarantee; a generic SyntaxRewriter renaming pass would be dead weight in
/// v1. What IS generated structurally:
/// - the new method declaration (signature line, static-ness mirrored from
/// the enclosing method, body = selected statements + appended
/// <c>return ...</c> for return slots the selection did not already end
/// with a return of),
/// - the call statement(s) replacing the selection,
/// - the insertion of the new method right after the enclosing one.
///
/// CALL-SITE RULES (per promoted return slots, v1):
/// - void → a plain call expression statement. A ref parameter already flows
/// the value back (e.g. Accumulate: <c>Extract(ref acc, n);</c>).
/// - one slot DECLARED inside the selection → redeclared at the call site
/// from the result: <c>int total = Extract(limit);</c>.
/// - one slot declared OUTSIDE → plain assignment: <c>acc = Extract(...);</c>.
/// - several slots ALL declared inside → tuple deconstruction:
/// <c>var (x, y) = Extract(n);</c>.
/// - several slots, any declared outside → capture + ItemN assignments
/// (the result is evaluated ONCE, then assigned member-wise).
/// - the enclosing method's return type is non-void and the selection ends
/// the method → the call site must be <c>return Extract(...);</c> and the
/// suggested return type must equal the enclosing one (otherwise: refuse).
///
/// REFUSALS (loud, never a silent wrong refactoring):
/// - the selection contains a return that does NOT end the enclosing method
/// (v1: select to the end of the method);
/// - the suggested return type does not match the enclosing method's return
/// type — including the em 03 "composite trailing return" case, where the
/// signature is void although the enclosing method returns a value (the
/// report's note already says: extract a local first, then re-run).
///
/// BUILDER STYLE: single-slot declarations and assignments are hand-built
/// with SyntaxFactory; the deconstruction call <c>var (x, y) = ...;</c> and
/// the tuple return <c>return (x, y);</c> are PARSED from a text skeleton and
/// the call slot swapped in via ReplaceNode — the parser knows the
/// designation/tuple-element shapes a v1 builder would get wrong. (Parse
/// diagnostics would surface as red nodes and fail the round-trip check
/// loudly, not silently.)
///
/// KNOWN v1 APPROXIMATIONS: type display strings are re-parsed for the
/// generated declarations (a tuple return with a comma-bearing generic type
/// element is not supported); the capture name <c>result</c> could in theory
/// collide with an enclosing local; the name check "suggested return type ==
/// enclosing return type" is a string comparison, not symbol equality.
/// </summary>
public static class RefactoringGenerator
{
public static Refactoring Generate(SemanticModel model, SelectionReport selection, SignatureSuggestion signature)
{
var method = selection.Method!;
var body = method.Body!;
var declaredInside = SignatureBuilder.DeclaredInsideNames(model, selection);
var slots = signature.ReturnSlots.ToList();
var slotNames = slots.Select(s => s.Name).ToList();
var containsReturn = selection.Statements.OfType<ReturnStatementSyntax>().Any();
var selectionEndsBody = ReferenceEquals(selection.Statements[^1], body.Statements[^1]);
var enclosingNonVoid = method.ReturnType is not PredefinedTypeSyntax voidType
|| !voidType.Keyword.IsKind(SyntaxKind.VoidKeyword);
var enclosingReturnType = method.ReturnType.ToString();
// ---- soundness refusals (see class comment) ----
if (containsReturn && enclosingNonVoid)
{
if (!selectionEndsBody)
{
throw new InvalidOperationException(
"the selection contains a return that does not end the enclosing method — select to the end of the method (v1 codegen)");
}
if (signature.ReturnType != enclosingReturnType)
{
throw new InvalidOperationException(
signature.ReturnType == "void"
? "the selection ends with the method's return, but its value is not nameable in v1 — " +
"extract it into a local first (see the report note), then re-run"
: $"the suggested return type {signature.ReturnType} does not match the enclosing method's " +
$"return type {enclosingReturnType} — refusing to generate");
}
}
// ---- the call expression (parameter names = source names, ref-ness kept) ----
var arguments = signature.Params
.Select(p =>
{
var argument = SyntaxFactory.Argument(SyntaxFactory.IdentifierName(p.Name));
return p.ByRef
? argument.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword))
: argument;
})
.ToList();
var invocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.IdentifierName(signature.MethodName))
.WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments)))
// Normalized once, here: the PARSED deconstruction skeleton (see
// BuildCallStatements) must not be re-normalized (the normalizer
// drops the space after the contextual keyword `var` before `(`),
// so it receives the invocation already properly spaced.
.NormalizeWhitespace();
// Normalizing only the GENERATED nodes keeps the original trivia —
// and therefore the doc comments — untouched (a whole-root
// NormalizeWhitespace corrupts doc-comment trivia in a way Roslyn's
// XML-doc writer rejects with CS1569, and it would also reformat the
// entire file, making the printed diff useless). The call statements
// and the new method get their indentation/end-of-line grafted from
// the selection they replace, so the edit slots into the original
// formatting.
var callStatements = BuildCallStatements(slots, slotNames, invocation, declaredInside,
callMustReturn: containsReturn && enclosingNonVoid).ToList();
var indent = SyntaxFactory.TriviaList(
selection.Statements[0].GetLeadingTrivia().Where(t => t.IsKind(SyntaxKind.WhitespaceTrivia)));
for (var index = 0; index < callStatements.Count; index++)
{
var call = callStatements[index].WithLeadingTrivia(indent);
if (index == callStatements.Count - 1)
{
// The replaced statement's trailing end-of-line kept the
// following token (the next statement or the closing brace)
// on its own line — carry it over.
call = call.WithTrailingTrivia(selection.Statements[^1].GetTrailingTrivia());
}
callStatements[index] = call;
}
// Normalize the new method INSIDE a throwaway class wrapper: the
// normalizer computes indentation from nesting depth, and a bare
// method node has none — its body would come out flush-left. At class
// depth the signature lands one level in and the body two. The grafted
// leading/trailing trivia below replaces whatever the wrapper put
// around the member.
var newMethod = (MethodDeclarationSyntax)SyntaxFactory.ClassDeclaration("__normalizer__")
.WithMembers(SyntaxFactory.SingletonList<MemberDeclarationSyntax>(
BuildNewMethod(method, selection, signature, slots, slotNames)))
.NormalizeWhitespace()
.Members[0];
var methodIndent = method.GetLeadingTrivia()
.LastOrDefault(t => t.IsKind(SyntaxKind.WhitespaceTrivia));
newMethod = newMethod
.WithLeadingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine("\n"), methodIndent))
.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n"));
// ---- apply to the tree: swap the selection for the call, add the method ----
var allStatements = body.Statements;
var firstIndex = allStatements.IndexOf(selection.Statements[0]); // reference identity: same tree
var newStatements = new List<StatementSyntax>();
newStatements.AddRange(allStatements.Take(firstIndex));
newStatements.AddRange(callStatements);
newStatements.AddRange(allStatements.Skip(firstIndex + selection.Statements.Count));
var rewrittenMethod = method.WithBody(body.WithStatements(SyntaxFactory.List(newStatements)));
// The new method lands right after the enclosing one, in the SAME type
// (that is what keeps the extract-first own-class members in scope).
var containingType = method.AncestorsAndSelf().OfType<TypeDeclarationSyntax>().First();
var memberIndex = containingType.Members.IndexOf(method);
var newType = containingType.WithMembers(
containingType.Members.Replace(method, rewrittenMethod).Insert(memberIndex + 1, newMethod));
var tree = model.SyntaxTree;
var visited = new SingleNodeReplacer(containingType, newType).Visit(tree.GetRoot());
if (visited is null)
{
throw new InvalidOperationException("the type replacement rewrote the root away (internal error)");
}
return new Refactoring(newMethod, callStatements, tree.WithRootAndOptions(visited, tree.Options));
}
/// <summary>
/// The one place a SyntaxRewriter enters this tool (yak em 04's stated
/// curriculum): swapping a single node by REFERENCE identity. The typed
/// With*-slices (WithBody, WithMembers) cover the local changes; only the
/// "put the rewritten type back into the root" step is a whole-tree walk.
/// </summary>
private sealed class SingleNodeReplacer : CSharpSyntaxRewriter
{
private readonly SyntaxNode _oldNode;
private readonly SyntaxNode _newNode;
public SingleNodeReplacer(SyntaxNode oldNode, SyntaxNode newNode)
{
_oldNode = oldNode;
_newNode = newNode;
}
public override SyntaxNode? Visit(SyntaxNode? node)
=> ReferenceEquals(node, _oldNode) ? _newNode : base.Visit(node);
}
/// <summary>The call statement(s) replacing the selection (see class comment).</summary>
private static IReadOnlyList<StatementSyntax> BuildCallStatements(
IReadOnlyList<ReturnSuggestion> slots,
IReadOnlyList<string> slotNames,
InvocationExpressionSyntax invocation,
ISet<string> declaredInside,
bool callMustReturn)
{
if (callMustReturn)
{
// The selection ends the enclosing (non-void) method: the call is
// the return value, the slots live in the new method.
return [Norm(SyntaxFactory.ReturnStatement(invocation))];
}
if (slots.Count == 0)
{
return [Norm(SyntaxFactory.ExpressionStatement(invocation))];
}
if (slots.Count == 1)
{
var slot = slots[0];
if (declaredInside.Contains(slot.Name))
{
// Declared inside the selection: redeclare it at the call site
// from the result (the declaration statement moved with the body).
var declarator = SyntaxFactory.VariableDeclarator(slot.Name)
.WithInitializer(SyntaxFactory.EqualsValueClause(invocation));
var declaration = SyntaxFactory.VariableDeclaration(
ParseType(slot.Type), SyntaxFactory.SingletonSeparatedList(declarator));
return [Norm(SyntaxFactory.LocalDeclarationStatement(declaration))];
}
// Declared outside: the caller already owns it (a parameter, or a
// local declared before the selection) — plain assignment.
return [Norm(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(slot.Name),
invocation)))];
}
// Several return slots.
if (slots.All(s => declaredInside.Contains(s.Name)))
{
// All declared inside: tuple deconstruction at the call site.
// Parsed from a skeleton (see class comment — builder style), the
// call swapped in at the placeholder identifier. NOT normalized:
// the skeleton text is already well-spaced, and NormalizeWhitespace
// would drop the space after the contextual keyword `var` (it is
// an identifier token to the normalizer, so `var (` becomes
// `var(`).
return [ParseStatementWithCall($"var ({string.Join(", ", slotNames)}) = __call__;", invocation)];
}
// Mixed: evaluate the call ONCE into a capture, then assign each slot
// from the matching ItemN. (Capture name collision with an enclosing
// local is a documented v1 limitation.)
var statements = new List<StatementSyntax>
{
Norm(SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VarKeyword)),
SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("result")
.WithInitializer(SyntaxFactory.EqualsValueClause(invocation)))))),
};
for (var index = 0; index < slots.Count; index++)
{
statements.Add(Norm(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(slots[index].Name),
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("result"),
SyntaxFactory.IdentifierName($"Item{index + 1}"))))));
}
return statements;
}
/// <summary>
/// Normalizes a builder-made statement: SyntaxFactory tokens carry no
/// trivia, so without this <c>return</c> and <c>Extract</c> would render
/// glued together. Only used for BUILDER statements — the parsed skeleton
/// statements are already well-spaced (see the deconstruction comment).
/// </summary>
private static StatementSyntax Norm(StatementSyntax statement) => statement.NormalizeWhitespace();
/// <summary>
/// Parses <paramref name="statementText"/> (containing the placeholder
/// identifier <c>__call__</c>) and swaps the placeholder for the built
/// <paramref name="invocation"/> — the parser supplies the syntax shapes
/// (tuple designations, tuple elements) the v1 builder avoids.
/// </summary>
private static StatementSyntax ParseStatementWithCall(string statementText, InvocationExpressionSyntax invocation)
{
var parsed = SyntaxFactory.ParseStatement(statementText);
var placeholder = parsed.DescendantNodes()
.OfType<IdentifierNameSyntax>()
.First(n => n.Identifier.ValueText == "__call__");
return parsed.ReplaceNode(placeholder, invocation);
}
/// <summary>
/// The extracted method: the promoted signature, static-ness mirrored from
/// the enclosing method, body = the selected statements plus an appended
/// <c>return</c> for the return slots (skipped when the selection already
/// ends in a return — a second one would be unreachable). The appended
/// tuple return is parsed from its text skeleton (see class comment).
/// </summary>
private static MethodDeclarationSyntax BuildNewMethod(
MethodDeclarationSyntax enclosingMethod,
SelectionReport selection,
SignatureSuggestion signature,
IReadOnlyList<ReturnSuggestion> slots,
IReadOnlyList<string> slotNames)
{
// A static enclosing method can only read statics and parameters, so
// the extracted body needs no instance — mirror the static modifier.
var modifiers = enclosingMethod.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword))
? new[] { SyntaxFactory.Token(SyntaxKind.StaticKeyword) }
: Array.Empty<SyntaxToken>();
var parameters = signature.Params
.Select(p =>
{
var parameter = SyntaxFactory.Parameter(SyntaxFactory.Identifier(p.Name))
.WithType(ParseType(p.Type));
return p.ByRef
? parameter.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.RefKeyword)))
: parameter;
})
.ToList();
var bodyStatements = selection.Statements.ToList();
if (slots.Count > 0 && selection.Statements[^1] is not ReturnStatementSyntax)
{
// The slot order here is the same name-ordered sequence the tuple
// ReturnType was built from, so the emitted value matches the
// declared element types.
bodyStatements.Add(slots.Count == 1
? SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(slotNames[0]))
: SyntaxFactory.ParseStatement($"return ({string.Join(", ", slotNames)});"));
}
return SyntaxFactory.MethodDeclaration(ParseType(signature.ReturnType), SyntaxFactory.Identifier(signature.MethodName))
.WithModifiers(SyntaxFactory.TokenList(modifiers))
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters)))
.WithBody(SyntaxFactory.Block(SyntaxFactory.List(bodyStatements)));
}
/// <summary>
/// Re-parses a type display string (em 02/03 are plain strings) in type
/// context — <c>ParseTypeName</c> handles plain names, generics and tuple
/// display strings <c>(T1, T2)</c> alike.
///
/// EXCEPT <c>void</c>: parsing "void" in TYPE context yields a node the
/// compiler rejects as a method return type with CS1547 (keyword 'void'
/// cannot be used in this context) — the parser that reads real method
/// declarations produces <c>PredefinedType(Token(VoidKeyword))</c>, so
/// that is what a void signature must be built from.
/// Single choke point for the string-to-syntax hop; its correctness is
/// enforced by the round-trip check and the tests, not by construction.
/// </summary>
private static TypeSyntax ParseType(string text) => text == "void"
? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword))
: SyntaxFactory.ParseTypeName(text);
}