Refactor Generators: extract SourceEmitting namespace, decompose ExecutionRuntime, add 59 tests

[Copilot]

The IncrementalGenerators namespace had monolithic classes mixing Roslyn concerns with string emission, significant duplication between execution paths, and no unit tests for source output logic.

New SourceEmitting namespace

Extracts all C# source string-building into small, focused, Roslyn-free classes testable with plain data records:

• CSharpLiteralFormatter — value/key → C# literal (string → "string", bool → true, enums → Type.Value)
• CSharpAccessibilityKeyword / CSharpTypeKeyword — enum → keyword mappers (ToKeyword(accessibility, defaultToPrivate) single method with parameter instead of separate methods)
• PartialMethodSourceEmitter — emits complete partial method source files from PartialMethodEmitData
• DummyImplementationEmitter — emits dummy partial implementations for execution compilations
• RoslynSymbolDataMapper — thin bridge: INamedTypeSymbol/IMethodSymbol → emit data records

// Before: Roslyn types threaded through string-building methods
AppendNamespaceAndTypeHeader(builder, containingType, partialMethod);

// After: data extraction separated from emission
PartialMethodEmitData emitData = RoslynSymbolDataMapper.ToPartialMethodEmitData(containingType, partialMethod);
return PartialMethodSourceEmitter.Emit(emitData, returnValueLiteral);

Decomposed GeneratesMethodExecutionRuntime

The 466-line class with duplicated compile→load→execute logic is split into:

• GeneratorAssemblyExecutor — shared compilation, AssemblyLoadContext setup, type/method resolution
• LoadedAssemblyContext (IDisposable) — owns the isolated ALC lifecycle (own file)
• BodyGenerationDataExtractor — reflection-based FluentBodyResult extraction
• AbstractionsAssemblyResolver — resolves the abstractions assembly from compilation references (file-based and in-memory)
• DataGeneratorsFactorySetup — wires up the DataGeneratorsFactory to Generate.CurrentGenerator
• DiagnosticMessageHelper — testable helper for joining error diagnostics into strings
• GeneratesMethodExecutionRuntime — now a thin orchestrator (~170 lines) delegating to the above

Tests & docs

• 59 new unit tests across 6 test files covering all SourceEmitting classes and DiagnosticMessageHelper
• /// <summary> on all internal/public methods
• All 218 test executions (net8.0 + net10.0) pass

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Refactor Generators code</issue_title>
<issue_description>Code under namespace EasySourceGenerators.Generators.IncrementalGenerators is currently a mess. Let's refactor it to be readable, maintanable and testable.

Besides general good coding rules, focus on:

• Don't store global state, pass necessary data as parameters
• Create small classes with small methods, that only do one thing
• make sure the classes are unit-testable
• if needed, create abstraction layer for Roslyn Generators and other parts. minimize using Roslyn Generators code to a small subset of classes that need them, making most of the code logic unit-testable without running any actuall generators
• extract all parts of code that emit code as strings (like "{" or "private") into separate namespace with separate classes. create unit tests for them.
• create documentation ///<summary> comments for internal/public methods when name is not enough</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Refactor Generators code #89

---

📍 Connect Copilot coding agent with Jira, Azure Boards or Linear to delegate work to Copilot in one click without leaving your project management tool.

[codecov]

Codecov Report

❌ Patch coverage is 73.33333% with 128 lines in your changes missing coverage. Please review.
✅ All tests successful. No failed tests found.

Files with missing lines	Patch %	Lines
...rementalGenerators/AbstractionsAssemblyResolver.cs	36.66%	34 Missing and 4 partials ⚠️
...IncrementalGenerators/GeneratorAssemblyExecutor.cs	65.68%	28 Missing and 7 partials ⚠️
...crementalGenerators/BodyGenerationDataExtractor.cs	35.00%	19 Missing and 7 partials ⚠️
...entalGenerators/GeneratesMethodExecutionRuntime.cs	67.44%	7 Missing and 7 partials ⚠️
...lGenerators/GeneratesMethodPatternSourceBuilder.cs	61.53%	4 Missing and 1 partial ⚠️
...ncrementalGenerators/DataGeneratorsFactorySetup.cs	69.23%	3 Missing and 1 partial ⚠️
...enerators/SourceEmitting/RoslynSymbolDataMapper.cs	93.84%	0 Missing and 4 partials ⚠️
...ors/IncrementalGenerators/LoadedAssemblyContext.cs	88.88%	2 Missing ⚠️

📢 Thoughts on this report? Let us know!

[dex3r]

Move into separate file

[Copilot]

Moved LoadedAssemblyContext to its own file LoadedAssemblyContext.cs in 174a3e2.

[dex3r]

Error joining to string should be a separate, testable helper method (in helpers class).

Also, it is too big, so it probably does too many things.

[Copilot]

Extracted DiagnosticMessageHelper.JoinErrorDiagnostics() as a testable helper with 5 unit tests. Also extracted AbstractionsAssemblyResolver and DataGeneratorsFactorySetup from the class to reduce its scope. Done in 174a3e2.

[dex3r]

This method should be a switch in From method, not an entire new method.

Also, the name "From" sucks, this doesnt tell me anything:
CSharpAccessibilityKeyword.From.

[Copilot]

Merged into a single method CSharpAccessibilityKeyword.ToKeyword(accessibility, defaultToPrivate: true). The defaultToPrivate parameter controls whether unrecognized/private values return "private" (default) or "". Done in 174a3e2.

[dex3r]

This class is still too big, meaning it probably does too many things.

[Copilot]

Extracted AbstractionsAssemblyResolver.Resolve(), DataGeneratorsFactorySetup.Setup(), and InvokeStaticMethod() private helper. GeneratesMethodExecutionRuntime is now a thin orchestrator — ~170 lines down from ~276. Done in 174a3e2.

[Copilot]

Pull request overview

This PR refactors generator implementation code by separating Roslyn symbol handling from C# source string emission, decomposing the compile→load→execute runtime into smaller components, and adding unit tests for the new emitters/helpers.

Changes:

• Introduce SourceEmitting namespace with Roslyn-free emitters/formatters plus a Roslyn→data mapper.
• Split the previous monolithic execution runtime into focused helpers (assembly compile/load, abstractions resolution, factory wiring, reflection extraction, diagnostic formatting).
• Add new unit tests covering source emission utilities and diagnostic formatting.

Reviewed changes

Copilot reviewed 24 out of 24 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
EasySourceGenerators.Generators/SourceEmitting/RoslynSymbolDataMapper.cs	Maps Roslyn symbols to plain emit-data records (bridge layer).
EasySourceGenerators.Generators/SourceEmitting/PartialMethodSourceEmitter.cs	Emits partial method implementation source from PartialMethodEmitData.
EasySourceGenerators.Generators/SourceEmitting/PartialMethodEmitData.cs	Data record for partial method emission.
EasySourceGenerators.Generators/SourceEmitting/DummyImplementationEmitter.cs	Emits dummy partial implementations for execution compilations.
EasySourceGenerators.Generators/SourceEmitting/CSharpTypeKeyword.cs	Maps TypeKind to declaration keyword.
EasySourceGenerators.Generators/SourceEmitting/CSharpLiteralFormatter.cs	Formats values/keys as C# literals for emission.
EasySourceGenerators.Generators/SourceEmitting/CSharpAccessibilityKeyword.cs	Maps Accessibility to C# keywords.
EasySourceGenerators.Generators/IncrementalGenerators/LoadedAssemblyContext.cs	Encapsulates collectible ALC + loaded assembly lifecycle.
EasySourceGenerators.Generators/IncrementalGenerators/GeneratorAssemblyExecutor.cs	Builds execution compilation, emits/loads assembly in isolated ALC, provides reflection helpers.
EasySourceGenerators.Generators/IncrementalGenerators/GeneratesMethodPatternSourceBuilder.cs	Refactors simple pattern source generation to delegate to SourceEmitting.
EasySourceGenerators.Generators/IncrementalGenerators/GeneratesMethodGenerator.cs	Adds docs; generator entry remains the same.
EasySourceGenerators.Generators/IncrementalGenerators/GeneratesMethodGenerationTargetCollector.cs	Adds docs; target collection/validation remains the same.
EasySourceGenerators.Generators/IncrementalGenerators/GeneratesMethodGenerationPipeline.cs	Adds docs; pipeline now calls refactored runtime/emitter components.
EasySourceGenerators.Generators/IncrementalGenerators/GeneratesMethodExecutionRuntime.cs	Becomes a thin orchestrator delegating to new helper classes.
EasySourceGenerators.Generators/IncrementalGenerators/DiagnosticMessageHelper.cs	Extracted helper for joining error diagnostics.
EasySourceGenerators.Generators/IncrementalGenerators/DataGeneratorsFactorySetup.cs	Wires DataGeneratorsFactory into Generate.CurrentGenerator in execution context.
EasySourceGenerators.Generators/IncrementalGenerators/BodyGenerationDataExtractor.cs	Extracts fluent body return data via reflection.
EasySourceGenerators.Generators/IncrementalGenerators/AbstractionsAssemblyResolver.cs	Resolves abstractions assembly from compilation references (file/in-memory).
EasySourceGenerators.GeneratorTests/PartialMethodSourceEmitterTests.cs	Tests for PartialMethodSourceEmitter.
EasySourceGenerators.GeneratorTests/DummyImplementationEmitterTests.cs	Tests for DummyImplementationEmitter.
EasySourceGenerators.GeneratorTests/DiagnosticMessageHelperTests.cs	Tests for DiagnosticMessageHelper.
EasySourceGenerators.GeneratorTests/CSharpTypeKeywordTests.cs	Tests for CSharpTypeKeyword.
EasySourceGenerators.GeneratorTests/CSharpLiteralFormatterTests.cs	Tests for CSharpLiteralFormatter.
EasySourceGenerators.GeneratorTests/CSharpAccessibilityKeywordTests.cs	Tests for CSharpAccessibilityKeyword.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

In the AssemblyLoadContext.Resolving handler, assemblies are loaded from new MemoryStream(bytes) without disposing the stream. Per AssemblyLoadContext.LoadFromStream guidance, the caller should own/dispose the stream; leaking streams here can add avoidable memory pressure when many resolutions occur. Consider wrapping the MemoryStream in a using (or reusing a pooled stream) before calling LoadFromStream.

Suggested change

	Assembly loaded = context.LoadFromStream(new MemoryStream(bytes));
	using MemoryStream assemblyStream = new(bytes);
	Assembly loaded = context.LoadFromStream(assemblyStream);

[Copilot]

LoadFromCompilationReference loads the abstractions assembly via new MemoryStream(abstractionBytes) but never disposes the stream. Disposing the stream after LoadFromStream avoids unnecessary allocations/retained buffers during generator execution. Consider using a using around the MemoryStream.

Suggested change

	Assembly assembly = context.LoadContext.LoadFromStream(new MemoryStream(abstractionBytes));
	using var stream = new MemoryStream(abstractionBytes);
	Assembly assembly = context.LoadContext.LoadFromStream(stream);

[Copilot]

FormatKeyAsLiteral falls back to key.ToString() for non-bool/non-string cases. This can emit invalid C# for common key types (e.g., char becomes A instead of 'A'), and floating-point/decimal formatting can become culture-dependent (comma vs dot) leading to non-compilable generated code on some locales. Consider adding explicit handling for char (and other primitives) via SyntaxFactory.Literal(...) / invariant formatting, and guard against typeDisplayString being null in the enum branch.

[Copilot]

Setup claims to return an error when required properties can't be found, but it currently silently succeeds if Generate.CurrentGenerator isn't found (currentGeneratorProperty is null) or if Activator.CreateInstance returns null. This can lead to confusing downstream failures when executing fluent generators. Consider validating that the property exists and is settable, and return a descriptive error if wiring fails.

Suggested change

	PropertyInfo? currentGeneratorProperty = generatorStaticType.GetProperty(
	Consts.CurrentGeneratorPropertyName, BindingFlags.NonPublic | BindingFlags.Static);
	currentGeneratorProperty?.SetValue(null, dataGeneratorsFactory);
	if (dataGeneratorsFactory is null)
	{
	return
	$"Could not create an instance of {Consts.DataGeneratorsFactoryTypeFullName}.";
	}
	PropertyInfo? currentGeneratorProperty = generatorStaticType.GetProperty(
	Consts.CurrentGeneratorPropertyName, BindingFlags.NonPublic | BindingFlags.Static);
	if (currentGeneratorProperty is null)
	{
	return
	$"Could not find static property {Consts.CurrentGeneratorPropertyName} on {Consts.GenerateTypeFullName}.";
	}
	if (!currentGeneratorProperty.CanWrite)
	{
	return
	$"Property {Consts.GenerateTypeFullName}.{Consts.CurrentGeneratorPropertyName} is not writable.";
	}
	if (!currentGeneratorProperty.PropertyType.IsAssignableFrom(dataGeneratorsFactoryType))
	{
	return
	$"Property {Consts.GenerateTypeFullName}.{Consts.CurrentGeneratorPropertyName} is of type {currentGeneratorProperty.PropertyType.FullName}, which is not assignable from {Consts.DataGeneratorsFactoryTypeFullName}.";
	}
	currentGeneratorProperty.SetValue(null, dataGeneratorsFactory);