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

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').

tools/ExtractMethod/Program.cs

@@ -46,18 +46,52 @@ if (!resolved.Succeeded)
 }
 
 // 4. compose the full suggestion (em 02 buckets + em 03 extract-first and
-//    signature) and print the report. A composition failure is a semantic
-//    resolution error: same exit code as the resolver, message on stderr,
-//    but never a stack trace.
+//    signature), generate the refactoring (em 04), verify it and print the
+//    diff. Any failure is a clean error: message on stderr, same exit code
+//    as the resolver, never a stack trace.
 var model = compilation.GetSemanticModel(tree);
 try
 {
     var extraction = ExtractionReporter.Compose(model, resolved);
     Console.Write(ReportFormatter.Format(extraction));
+
+    // 5. generate the refactoring from the suggestion (em 04 codegen): new
+    //    method + rewritten call site + transformed tree.
+    var refactoring = RefactoringGenerator.Generate(model, resolved, extraction.Signature);
+
+    // 6. round-trip check: the generated code must compile with zero
+    //    diagnostics (same scratch-compilation path as the input file).
+    var transformedCompilation = CompilationLoader.CreateCompilation(
+        refactoring.TransformedTree, Path.GetFileNameWithoutExtension(file));
+    var diagnostics = transformedCompilation.GetDiagnostics().ToList();
+    if (diagnostics.Count > 0)
+    {
+        Console.Error.WriteLine(
+            $"error: round-trip check failed — the generated code has {diagnostics.Count} diagnostic(s):");
+        foreach (var diagnostic in diagnostics)
+        {
+            Console.Error.WriteLine($"  {diagnostic}");
+        }
+
+        Console.Error.WriteLine("---- generated code ----");
+        Console.Error.Write(refactoring.TransformedText);
+        return SelectionResolver.ExitError;
+    }
+
+    // 7. v1 decision (em 04): print a unified diff to stdout — PREVIEW, never
+    //    an in-place file rewrite. Applying the diff (or a future --write
+    //    flag with backup semantics) is a deliberate next step, because
+    //    mutating the caller's file is a different safety policy than
+    //    generating code.
+    Console.Write(UnifiedDiff.Diff(
+        tree.ToString(),
+        refactoring.TransformedText,
+        Path.GetFileName(file),
+        Path.GetFileName(file) + " (generated)"));
 }
 catch (Exception e) when (e is InvalidOperationException or ArgumentException)
 {
-    Console.Error.WriteLine($"error: data-flow analysis failed: {e.Message}");
+    Console.Error.WriteLine($"error: {e.Message}");
     return SelectionResolver.ExitError;
 }