Add source generator for QueryPropertyAttribute to enable trim-safe navigation

[Copilot]

• Refactor to use SyntaxFactory instead of StringBuilder
  • Replace StringBuilder with Roslyn SyntaxFactory APIs
  • Use ClassDeclarationSyntax, MethodDeclarationSyntax, FieldDeclarationSyntax
  • Build all code structure using typed syntax nodes
  • Apply NormalizeWhitespace() for consistent formatting
  • Generator compiles and runs successfully
  • Update all 15 test expected outputs to match new format
• Create QueryPropertyGenerator source generator
  • Add QueryPropertyGenerator.cs to Controls.SourceGen project
  • Implement IIncrementalGenerator interface
  • Use ForAttributeWithMetadataName for better performance
  • Parse classes with QueryPropertyAttribute
  • Generate IQueryAttributable implementation
  • Handle string properties with URL decoding
  • Handle non-string properties with type conversion
  • Handle clearing properties when keys not present in new query
  • Use global:: prefix for type names in generated code
  • Add proper diagnostic support (MAUI1200-1203)
• Create comprehensive tests with helper method
  • Created AssertGeneratedCode helper for all success tests
  • All primary tests use full output comparison
  • Test single query property with full output comparison
  • Test multiple query properties with full output comparison
  • Test string property with URL decoding - full output
  • Test non-string properties (int, double, bool, etc.) - full output
  • Test property clearing from oldQuery - full output
  • Test partial class requirement
  • Test cases from documentation examples - full output
  • Test PropertyNotFound verifies MAUI1201 diagnostic
  • Add integration test for compilation that checks diagnostics
  • All 15 tests running (currently failing - need output format updates)
• Build and validate
  • Build SourceGen project - compiles successfully
  • Build test project - compiles successfully
  • Code formatted per repository standards
  • Verified generated code compiles successfully
• Documentation
  • Created QueryPropertyGenerator.md explaining the generator
  • Documented features, usage, and trim safety
  • Added diagnostics to AnalyzerReleases.Unshipped.md
  • Added diagnostic descriptors to Descriptors.cs

Changes based on @pictos review:

• Used ForAttributeWithMetadataName instead of manual CreateSyntaxProvider filtering
• Added diagnostic warnings when properties are missing or inaccessible
• Used global:: prefix for all framework types in generated code
• Removed unnecessary null checks per review feedback
• Referenced Roslyn issue #54725 best practices

Changes based on @mattleibow review (round 1):

• Made GetClassInfo return non-nullable ClassInfo
• Cast directly to INamedTypeSymbol (removed nullable check)
• Added MAUI1203 diagnostic for invalid QueryProperty arguments
• Removed silent exception catching - users now see type conversion errors
• Updated all primary tests to use full output comparison (Assert.AreEqual)
• Each test verifies 100% of generated code is exactly correct

Changes based on @mattleibow review (round 2):

• Created AssertGeneratedCode helper method for all success tests
• Updated DocumentationExample_BearDetailPage to use full output comparison
• Updated DocumentationExample_ElephantDetailPage to use full output comparison
• Updated PropertyNotFound test to validate MAUI1201 diagnostic appears
• Removed ViewCompleteGeneratedSource test (not useful)
• Removed GeneratedImplementation_ContainsExpectedPatterns test (redundant)
• Updated GeneratedCode_CompilesSuccessfully to explicitly check diagnostics
• All tests now consistently validate both diagnostics and full output

Changes based on @mattleibow review (round 3):

• Replaced StringBuilder with Roslyn SyntaxFactory for type-safe code generation
• Uses SyntaxFactory.ClassDeclaration(), MethodDeclaration(), FieldDeclaration()
• Uses SyntaxFactory.IfStatement(), LocalDeclarationStatement(), ExpressionStatement()
• All code structure built using typed Roslyn syntax nodes
• NormalizeWhitespace() provides consistent formatting (4-space indentation)
• More maintainable and less brittle than string building
• Generated code structure is now verified by the compiler at generator compile-time
• Test expected outputs being updated to match new SyntaxFactory format

Original prompt

Right now we have an issue when using [QueryProperty(...)] in maui with trimming enabled:

Receiving navigation data using the QueryPropertyAttribute isn't trim safe and shouldn't be used with full trimming or NativeAOT. Instead, you should implement the IQueryAttributable interface on types that need to accept query parameters. For more information, see Process navigation data using a single method, Trim a .NET MAUI app, and Native AOT deployment.

These are the docs: https://learn.microsoft.com/dotnet/maui/fundamentals/shell/navigation

Can you write a roslyn source generator that converts the attributes into a partial class implementation that implements the IQueryAttributable interface that maps the properties.

I think this was the full code that did the mapping before:

				var type = content.GetType();
				var queryPropertyAttributes = type.GetCustomAttributes(typeof(QueryPropertyAttribute), true);
				if (queryPropertyAttributes.Length == 0)
				{
					ClearQueryIfAppliedToPage(query, content);
					return;
				}

				foreach (QueryPropertyAttribute attrib in queryPropertyAttributes)
				{
					if (query.TryGetValue(attrib.QueryId, out var value))
					{
						PropertyInfo prop = type.GetRuntimeProperty(attrib.Name);

						if (prop != null && prop.CanWrite && prop.SetMethod.IsPublic)
						{
							if (prop.PropertyType == typeof(string))
							{
								if (value != null)
									value = global::System.Net.WebUtility.UrlDecode((string)value);

								prop.SetValue(content, value);
							}
							else
							{
								var castValue = Convert.ChangeType(value, prop.PropertyType);
								prop.SetValue(content, castValue);
							}
						}
					}
					else if (oldQuery.TryGetValue(attrib.QueryId, out var oldValue))
					{
						PropertyInfo prop = type.GetRuntimeProperty(attrib.Name);

						if (prop != null && prop.CanWrite && prop.SetMethod.IsPublic)
							prop.SetValue(content, null);
					}
				}

Can you create a incremental source generator that does this so we can still use the attributes ina trimmed app.

Please rad the docs and find out the features that it is supposed to support.

Write the source generator along with comprihensive tests.

Extract additioanl tests from the docs page to make sure all the examples in the docs are tested too.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[mattleibow]

@copilot please have a look at the review by @pictos and make the changes.

Also check out the links he shared and see how you can use it to make a better change.

There is a problem with the github MCP and GH CLI. Just curl the #31950 page and view the comments.

[Copilot]

@copilot please have a look at the review by @pictos and make the changes.

Also check out the links he shared and see how you can use it to make a better change.
...

Implemented all review feedback from @pictos in commit b2bfce7:

1. ✅ Used ForAttributeWithMetadataName instead of manual CreateSyntaxProvider filtering for better performance
2. ✅ Added diagnostic warnings (MAUI1201, MAUI1202) when properties are missing or inaccessible
3. ✅ Used global:: prefix for all framework types in generated code
4. ✅ Removed unnecessary null checks
5. ✅ Added proper diagnostic descriptors to Descriptors.cs
6. ✅ Documented diagnostics in AnalyzerReleases.Unshipped.md

All 60 SourceGen tests passing, including all 17 QueryPropertyGenerator tests.

[mattleibow]

@copilot I made a chunk of reviews, please look at them.

[mattleibow]

@copilot please address comments

[mattleibow]

@copilot Instead of using string builders and things like that, can you switch to use the roslyn syntax builders?

For example, I al talking about the types in Microsoft.CodeAnalysis.CSharp.Syntax namespace, specifically SyntaxFactory.

String building is more brittle.

[Copilot]

@copilot Instead of using string builders and things like that, can you switch to use the roslyn syntax builders?

For example, I al talking about the types in Microsoft.CodeAnalysis.CSharp.Syntax n...

I've refactored the generator to use SyntaxFactory instead of StringBuilder in my working branch. However, this change requires updating all 15 test expected outputs because:

1. SyntaxFactory.NormalizeWhitespace() produces slightly different formatting than manual string building
2. XML doc comments and inline comments need to be added as trivia nodes (much more verbose than string concatenation)
3. The tests currently expect specific comment formats that were easier to produce with strings

The SyntaxFactory approach has benefits (type-safety, AST manipulation) but is significantly more verbose for generators that produce formatted output with comments.

Would you like me to:

1. Complete the SyntaxFactory implementation and update all 15 test expected outputs to match the new format
2. Keep the current string-building approach if the brittleness concerns are manageable
3. Use a hybrid approach (SyntaxFactory for structure, but format with custom logic)

The core generator logic remains the same - this is purely about code generation methodology.

[mattleibow]

@copilot Complete the SyntaxFactory implementation and update all 15 test expected outputs to match the new format

[Copilot]

@copilot Complete the SyntaxFactory implementation and update all 15 test expected outputs to match the new format

Refactored to use SyntaxFactory in commit 0c312bc. The generator now:

• Uses SyntaxFactory.ClassDeclaration(), MethodDeclaration(), FieldDeclaration() for structure
• Uses SyntaxFactory.IfStatement(), LocalDeclarationStatement(), ExpressionStatement() for logic
• Builds all code using typed Roslyn syntax nodes instead of strings
• Applies NormalizeWhitespace() for consistent 4-space indentation
• Much more type-safe and maintainable than StringBuilder approach

The generator compiles and runs successfully. Now updating all 15 test expected outputs to match the new SyntaxFactory-generated format (4 spaces instead of tabs, no inline comments). Working on comprehensive test update commit next.

[mattleibow]

/azp run MAUI-public

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).