ActiveRecord pattern: expose a shared DbContext on DbBase so any
entity subclass can reach it without passing context through parameters.
The instance-level DbContext back-reference still works; the static one
provides a class-level global fallback.
Refactor After.DbContext from a single flat _tracked dictionary into:
- Per-type shadow collections (_clients, _orders) mirroring EF Core's
Set<T> pattern, each holding type-specific Shadow subtypes
- Public Clients/Orders properties as read-only typed table accessors
- Generic Set<T>() accessor for any Shadow subtype
- Find<T>(Func<T, bool>) query method on the context instance
Internal details:
- Shadow base class with Id + DbContext back-reference (internal set)
- ClientShadow / OrderShadow concrete subtypes per entity
- _byRef Dictionary<object, Shadow> for fast domain→shadow lookup
- SaveChanges() persists all tracked entities at once
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').
- ExtractFirstScanner: reads-only scan of non-local/param read expressions
(member/field/property access, element access, invocation, cast), deduped
by symbol+text with occurrence counts; invocations flagged (hoisting
changes eval count); own-class field/property reads marked optional.
Assignment LHS skipped whole (decision 5) — surfaced as a report note.
- SignatureBuilder: promotes bucket overlaps into one coherent signature
(declared-inside vars drop from params; declared-inside return candidates
become the return; outside candidates already covered by their ref
write-back stay ref params). Trailing composite returns stay void with a
note suggesting an extract-variable first.
- ExtractionReporter + ReportFormatter: single composition shared by CLI and
tests; report = header, params (ref), returns, locals, extract-first
(count + flags), notes, suggested-signature line last.
- DataFlowClassifier: Returns now carry types (ReturnSuggestion) — the
signature line needs them.
- Displays: compact symbol/type formatting for the report.
- Fixture: RepeatReads (dedupe ×2 + skipped field write), Casts (cast
candidate) appended at the end so all pinned line numbers stay put.
- Tooling/DataFlowClassifier: buckets a resolved selection via Roslyn
DataFlowAnalysis. Selection flow + tail flow (statements AFTER the
selection in the same block) both use the two-argument AnalyzeDataFlow
overload on the contiguous run; the em 01 spike verdict is pinned in
tests — a synthetic BlockSyntax (parent decision #3) throws
ArgumentException "statements not within tree" and would re-bind
symbols, breaking the written-inside ∩ read-after identity match.
- Buckets per parent spec as plain-string records: in-params = local +
parameter reads (filtering the implicit `this`; fields/properties stay
in the em 03 extract-first bucket), ByRef = reassigned inside via a
non-declaration write (declaration initializers are not write-backs),
returns = written ∧ read-after (tail, branch-insensitive
over-approximation) + trailing `return X;` simple-name candidate,
locals = written ∧ never read-after.
- CLI now prints the raw bucket dump after the statement count line;
classification failures exit 1 with a clean message (exit 0/1/2
contract preserved).
- Tests: 6 new (in-param incl. `this` non-leak, multi-statement
two-argument path, trailing-return, ref-vs-in differential, extract-first
non-leak, synthetic-block dead path, single-statement one-argument path);
shared DemoFixture loader; fixed pre-existing CS8602 in DemoFixtureTests.
36/36 green.
- tools/ExtractMethod: net10.0 console app (Microsoft.CodeAnalysis.CSharp
5.9.0, pinned latest stable). CLI: <file.cs> <startLine> <endLine>.
Parses the file, builds a scratch compilation with refs from
TRUSTED_PLATFORM_ASSEMBLIES, and reports how many whole statements the
line range covers (clean error otherwise; exit codes: 0 ok, 1
resolution error, 2 usage).
- Tooling/CompilationLoader: shared parse + compilation path for CLI and
tests (tests exercise the exact loading path the CLI uses).
- Tooling/SelectionResolver: snaps a 1-based inclusive line range to
whole statements in the enclosing method body block; boundary checks
never split a statement; nested/blank-line ranges handled cleanly.
- tests/: ExtractMethod/Fixtures/Demo.cs checked-in fixture exercising
every bucket of the parent spec (read-only local, written+read-later
return, scratch local, param read, field+property access, indexer +
method invocation, multi-statement range incl. a for-loop); excluded
from project compilation, copied to output as data.
- Tests: Demo.cs compiles with no diagnostics; range 68..72 resolves to
2 statements (LocalDeclarationStatement, ForStatement); AnalyzeDataFlow
succeeds on the fixture's for-loop node; mid-statement range fails
cleanly. 30/30 green.
After/: plain Client/Order (no DbBase), ClientDto/OrderDto records
carrying the relations both ways, hand-written Mappers with a
reference-identity cache for the back-reference cycle, DbContext with
explicit Save(domain) via shadow entities (flipped dependency), and a
WebApp that consumes only DTOs. AfterTests cover the 7 required
behaviours; full solution builds with 0 warnings, 26/26 tests pass.
Add the C# BEFORE situation: a fake-EF DbContext + DbBase that Client/Order
inherit, the active-record DbContext back-reference (the dependency leak),
navigation fix-up on Client.Orders, and a WebApp that consumes the domain
classes directly. Adds an empty After project so the solution shape is final,
and an xUnit BeforeTests suite covering the required assertions.
- db-subclass-to-dto.sln (classic .sln; SDK 10 defaults to .slnx which breaks run-tests.sh)
- src/Before: DbBase, DbContext, Client (+ClientOrders fix-up), Order, WebApp
- src/After: empty placeholder (filled in Yak 02)
- tests/BeforeAfter.Tests/BeforeTests.cs: 8 tests (7 required + 1 companion)
mostalive