From 73ccd7ac76358f3303550fb7384e591bb68bb805 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 12 May 2026 04:07:06 -0700 Subject: [PATCH 001/171] Add interpolated-string handler to IndentedTextWriter Introduce AppendInterpolatedStringHandler (ref struct) to support compiler-backed interpolated-string appends into IndentedTextWriter. The new handler (internal, EditorBrowsable(Never), [InterpolatedStringHandler]) handles literals, formatted values (with optional format), ReadOnlySpan, and preserves multiline semantics (CRLF -> LF normalization and per-line indentation); it leverages StringBuilder's handler for non-string formatting to avoid allocations. Also make IndentedTextWriter partial, add the necessary System.Runtime.CompilerServices import, and add two Write overloads annotated with [InterpolatedStringHandlerArgument] so the compiler can bind interpolated strings to the new handler. --- ...tWriter.AppendInterpolatedStringHandler.cs | 132 ++++++++++++++++++ .../Writers/IndentedTextWriter.cs | 24 +++- 2 files changed, 155 insertions(+), 1 deletion(-) create mode 100644 src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs new file mode 100644 index 000000000..b452d6a70 --- /dev/null +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -0,0 +1,132 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System; +using System.ComponentModel; +using System.Runtime.CompilerServices; +using System.Text; + +namespace WindowsRuntime.ProjectionWriter.Writers; + +/// +internal partial class IndentedTextWriter +{ + /// + /// Provides a handler used by the language compiler to append interpolated strings into instances. + /// + [EditorBrowsable(EditorBrowsableState.Never)] + [InterpolatedStringHandler] + public readonly ref struct AppendInterpolatedStringHandler + { + /// The associated to which to append. + private readonly IndentedTextWriter _writer; + + /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). + private readonly bool _isMultiline; + + /// Creates a handler used to append an interpolated string into a . + /// The number of constant characters outside of interpolation expressions in the interpolated string. + /// The number of interpolation expressions in the interpolated string. + /// The associated to which to append. + /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. + public AppendInterpolatedStringHandler( + int literalLength, + int formattedCount, + IndentedTextWriter writer) + { + _writer = writer; + _isMultiline = false; + } + + /// Creates a handler used to append an interpolated string into a . + /// The number of constant characters outside of interpolation expressions in the interpolated string. + /// The number of interpolation expressions in the interpolated string. + /// The associated to which to append. + /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). + /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. + public AppendInterpolatedStringHandler( + int literalLength, + int formattedCount, + IndentedTextWriter writer, + bool isMultiline) + { + _writer = writer; + _isMultiline = isMultiline; + } + + /// Writes the specified string to the handler. + /// The string to write. + public void AppendLiteral(string value) + { + _writer.Write(value, _isMultiline); + } + + /// Writes the specified value to the handler. + /// The value to write. + /// The type of the value to write. + public void AppendFormatted(T value) + { + if (value is null) + { + return; + } + + // If the value is a 'string', write it while preserving the multiline semantics. + // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. + if (value is string text) + { + _writer.Write(text, _isMultiline); + } + else + { + _ = _writer._buffer.Append($"{value}"); + } + } + + /// Writes the specified value to the handler. + /// The value to write. + /// The format string. + /// The type of the value to write. + public void AppendFormatted(T value, string? format) + { + if (value is null) + { + return; + } + + // If the value is a 'string', write it while preserving the multiline semantics. + // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. + if (value is string text) + { + _writer.Write(text, _isMultiline); + } + else + { + StringBuilder.AppendInterpolatedStringHandler handler = new(0, 1, _writer._buffer); + + handler.AppendFormatted(value, format); + + _ = _writer._buffer.Append(ref handler); + } + } + + /// Writes the specified character span to the handler. + /// The span to write. + public void AppendFormatted(ReadOnlySpan value) + { + _writer.Write(value, _isMultiline); + } + + /// Writes the specified value to the handler. + /// The value to write. + public void AppendFormatted(string? value) + { + if (value is null) + { + return; + } + + _writer.Write(value, _isMultiline); + } + } +} diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index 751b6b694..517d8052d 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -7,6 +7,7 @@ using System; using System.IO; +using System.Runtime.CompilerServices; using System.Text; namespace WindowsRuntime.ProjectionWriter.Writers; @@ -29,7 +30,7 @@ namespace WindowsRuntime.ProjectionWriter.Writers; /// indentation, so raw multi-line literals with blank lines do not gain trailing whitespace. /// /// -internal sealed class IndentedTextWriter +internal sealed partial class IndentedTextWriter { /// /// The default indentation (4 spaces). @@ -115,6 +116,27 @@ public Block WriteBlock() return new Block(this); } + /// + /// Writes an interpolated expression to the underlying buffer, applying current indentation + /// at the start of each new line. + /// + /// The interpolated content to write. + public void Write([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler) + { + _ = this; + } + + /// + /// Writes an interpolated expression to the underlying buffer, applying current indentation + /// at the start of each new line. + /// + /// When , treats as multiline (normalizes CRLF -> LF and indents every line). + /// The interpolated content to write. + public void Write(bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) + { + _ = this; + } + /// /// Writes to the underlying buffer, applying current indentation /// at the start of each new line. From 1a2cb46bb49ee5c28b232e504dd3d03aef849d3f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 12 May 2026 04:25:48 -0700 Subject: [PATCH 002/171] Refactor IndentedTextWriter overloads and logic Rework IndentedTextWriter surface and internals: reorder Write/WriteIf/WriteLine overloads to take the isMultiline flag first, add convenience overloads for string and ReadOnlySpan, and expose interpolated-string handler overloads for Write/WriteLine. Tighten behaviour: early-return on empty spans, improve newline insertion when previous buffer ends with '{' or '}', and centralize indentation handling in WriteRawText. Also update AppendInterpolatedStringHandler to accept a scoped ReadOnlySpan, remove ToStringAndClear, and ensure Clear resets indentation. Includes XML doc/remarks linking and small comment/formatting tweaks. --- ...tWriter.AppendInterpolatedStringHandler.cs | 2 +- .../Writers/IndentedTextWriter.cs | 160 +++++++++++++----- 2 files changed, 122 insertions(+), 40 deletions(-) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index b452d6a70..f1870e02b 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -112,7 +112,7 @@ public void AppendFormatted(T value, string? format) /// Writes the specified character span to the handler. /// The span to write. - public void AppendFormatted(ReadOnlySpan value) + public void AppendFormatted(scoped ReadOnlySpan value) { _writer.Write(value, _isMultiline); } diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index 517d8052d..fba42dbda 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -23,7 +23,7 @@ namespace WindowsRuntime.ProjectionWriter.Writers; /// equivalent design. /// /// -/// Indentation is applied per line: the first after a +/// Indentation is applied per line: the first after a /// newline (or at buffer start) prepends the current indentation string; mid-line writes do not. /// Multiline content (passed with isMultiline: true) normalizes CRLF -> LF /// and indents each line via the current indentation level. Empty lines never receive @@ -72,6 +72,7 @@ public IndentedTextWriter() _currentIndentation = string.Empty; _availableIndentations = new string[4]; _availableIndentations[0] = string.Empty; + for (int i = 1; i < _availableIndentations.Length; i++) { _availableIndentations[i] = _availableIndentations[i - 1] + DefaultIndentation; @@ -100,6 +101,7 @@ public void IncreaseIndent() public void DecreaseIndent() { CurrentIndentLevel--; + _currentIndentation = _availableIndentations[CurrentIndentLevel]; } @@ -113,7 +115,8 @@ public Block WriteBlock() { WriteLine("{"); IncreaseIndent(); - return new Block(this); + + return new(this); } /// @@ -121,40 +124,61 @@ public Block WriteBlock() /// at the start of each new line. /// /// The interpolated content to write. + /// public void Write([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler) { _ = this; } /// - /// Writes an interpolated expression to the underlying buffer, applying current indentation - /// at the start of each new line. + /// Writes an interpolated expression to the underlying buffer, applying current indentation at the start of each new line. /// /// When , treats as multiline (normalizes CRLF -> LF and indents every line). /// The interpolated content to write. + /// public void Write(bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) { _ = this; } /// - /// Writes to the underlying buffer, applying current indentation - /// at the start of each new line. + /// Writes to the underlying buffer, applying current indentation at the start of each new line. /// /// The content to write. + /// + public void Write(string content) + { + Write(isMultiline: false, content.AsSpan()); + } + + /// + /// Writes to the underlying buffer, applying current indentation at the start of each new line. + /// /// When , treats as multiline (normalizes CRLF -> LF and indents every line). - public void Write(string content, bool isMultiline = false) + /// The content to write. + /// + public void Write(bool isMultiline, string content) + { + Write(isMultiline, content.AsSpan()); + } + + /// + /// Writes to the underlying buffer, applying current indentation at the start of each new line. + /// + /// The content to write. + public void Write(ReadOnlySpan content) { - Write(content.AsSpan(), isMultiline); + Write(isMultiline: false, content); } /// /// Writes to the underlying buffer, applying current indentation /// at the start of each new line. /// - /// The content to write. + /// /// When , treats as multiline (normalizes CRLF -> LF and indents every line). - public void Write(scoped ReadOnlySpan content, bool isMultiline = false) + /// The content to write. + public void Write(bool isMultiline, ReadOnlySpan content) { if (isMultiline) { @@ -202,12 +226,27 @@ public void Write(scoped ReadOnlySpan content, bool isMultiline = false) /// /// When , writes ; otherwise this call is a no-op. /// The content to write. + /// + public void WriteIf(bool condition, string content) + { + if (condition) + { + Write(isMultiline: false, content.AsSpan()); + } + } + + /// + /// Writes to the underlying buffer if is ; otherwise does nothing. + /// + /// When , writes ; otherwise this call is a no-op. /// When , treats as multiline. - public void WriteIf(bool condition, string content, bool isMultiline = false) + /// The content to write. + /// + public void WriteIf(bool condition, bool isMultiline, string content) { if (condition) { - Write(content.AsSpan(), isMultiline); + Write(isMultiline, content.AsSpan()); } } @@ -216,12 +255,27 @@ public void WriteIf(bool condition, string content, bool isMultiline = false) /// /// When , writes ; otherwise this call is a no-op. /// The content to write. + /// + public void WriteIf(bool condition, ReadOnlySpan content) + { + if (condition) + { + Write(isMultiline: false, content); + } + } + + /// + /// Writes to the underlying buffer if is ; otherwise does nothing. + /// + /// When , writes ; otherwise this call is a no-op. /// When , treats as multiline. - public void WriteIf(bool condition, scoped ReadOnlySpan content, bool isMultiline = false) + /// The content to write. + /// + public void WriteIf(bool condition, bool isMultiline, ReadOnlySpan content) { if (condition) { - Write(content, isMultiline); + Write(isMultiline, content); } } @@ -254,32 +308,66 @@ public void WriteLine(bool skipIfPresent = false) } /// - /// Writes a newline to the underlying buffer unconditionally. Equivalent to - /// WriteLine(skipIfPresent: false). + /// Writes an interpolated expression to the underlying buffer and appends a trailing newline. /// - public void WriteRawNewLine() + /// The interpolated content to write. + /// + public void WriteLine([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler) { - _ = _buffer.Append(DefaultNewLine); + WriteLine(); + } + + /// + /// Writes an interpolated expression to the underlying buffer and appends a trailing newline. + /// + /// When , treats as multiline. + /// The interpolated content to write. + /// + public void WriteLine(bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) + { + WriteLine(); } /// /// Writes to the underlying buffer and appends a trailing newline. /// /// The content to write. + /// + public void WriteLine(string content) + { + WriteLine(isMultiline: false, content.AsSpan()); + } + + /// + /// Writes to the underlying buffer and appends a trailing newline. + /// /// When , treats as multiline. - public void WriteLine(string content, bool isMultiline = false) + /// The content to write. + /// + public void WriteLine(bool isMultiline, string content) { - WriteLine(content.AsSpan(), isMultiline); + WriteLine(isMultiline, content.AsSpan()); } /// /// Writes to the underlying buffer and appends a trailing newline. /// /// The content to write. + /// + public void WriteLine(ReadOnlySpan content) + { + WriteLine(isMultiline: false, content); + } + + /// + /// Writes to the underlying buffer and appends a trailing newline. + /// /// When , treats as multiline. - public void WriteLine(scoped ReadOnlySpan content, bool isMultiline = false) + /// The content to write. + /// + public void WriteLine(bool isMultiline, ReadOnlySpan content) { - Write(content, isMultiline); + Write(isMultiline, content); WriteLine(); } @@ -302,11 +390,12 @@ public void WriteLineIf(bool condition, bool skipIfPresent = false) /// When , writes +newline; otherwise this call is a no-op. /// The content to write. /// When , treats as multiline. + /// public void WriteLineIf(bool condition, string content, bool isMultiline = false) { if (condition) { - WriteLine(content.AsSpan(), isMultiline); + WriteLine(isMultiline, content.AsSpan()); } } @@ -316,26 +405,16 @@ public void WriteLineIf(bool condition, string content, bool isMultiline = false /// When , writes +newline; otherwise this call is a no-op. /// The content to write. /// When , treats as multiline. - public void WriteLineIf(bool condition, scoped ReadOnlySpan content, bool isMultiline = false) + /// + public void WriteLineIf(bool condition, ReadOnlySpan content, bool isMultiline = false) { if (condition) { - Write(content, isMultiline); + Write(isMultiline, content); WriteLine(); } } - /// - /// Returns the current buffer contents (trimmed) and clears the buffer. - /// - /// The text accumulated so far, trimmed of leading/trailing whitespace. - public string ToStringAndClear() - { - string text = _buffer.ToString().Trim(); - _ = _buffer.Clear(); - return text; - } - /// /// Returns the current buffer contents without modifying the buffer. /// @@ -384,6 +463,7 @@ public void ResetIndent() public void Clear() { _ = _buffer.Clear(); + ResetIndent(); } @@ -439,20 +519,22 @@ public string FlushToString() /// at the start of a new line. /// /// The raw text to write. - private void WriteRawText(scoped ReadOnlySpan content) + private void WriteRawText(ReadOnlySpan content) { - // Skip writing indent for empty content so that empty lines never receive - // trailing whitespace from the indentation prefix. + // Skip writing indent for empty content so that empty lines never + // receive trailing whitespace from the indentation prefix. if (content.IsEmpty) { return; } + // Add the indentation if this is the very start of a new line if (_buffer.Length == 0 || _buffer[^1] == DefaultNewLine) { _ = _buffer.Append(_currentIndentation); } + // Append the content after the correct indentation _ = _buffer.Append(content); } From a0e39fa0f1b0faca2405065897dbb5675fc7762d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 10:39:56 -0700 Subject: [PATCH 003/171] Correct _writer.Write argument order Pass _isMultiline as the first argument to _writer.Write across IndentedTextWriter.AppendInterpolatedStringHandler. Updated calls in AppendLiteral and the various AppendFormatted overloads to match the expected Write(bool, ...) signature and avoid swapping the value and boolean parameters. --- ...dentedTextWriter.AppendInterpolatedStringHandler.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index f1870e02b..863ea023f 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -58,7 +58,7 @@ public AppendInterpolatedStringHandler( /// The string to write. public void AppendLiteral(string value) { - _writer.Write(value, _isMultiline); + _writer.Write(_isMultiline, value); } /// Writes the specified value to the handler. @@ -75,7 +75,7 @@ public void AppendFormatted(T value) // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) { - _writer.Write(text, _isMultiline); + _writer.Write(_isMultiline, text); } else { @@ -98,7 +98,7 @@ public void AppendFormatted(T value, string? format) // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) { - _writer.Write(text, _isMultiline); + _writer.Write(_isMultiline, text); } else { @@ -114,7 +114,7 @@ public void AppendFormatted(T value, string? format) /// The span to write. public void AppendFormatted(scoped ReadOnlySpan value) { - _writer.Write(value, _isMultiline); + _writer.Write(_isMultiline, value); } /// Writes the specified value to the handler. @@ -126,7 +126,7 @@ public void AppendFormatted(string? value) return; } - _writer.Write(value, _isMultiline); + _writer.Write(_isMultiline, value); } } } From 013f12520892c94493e63cf30fe47f2419853f62 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 10:56:38 -0700 Subject: [PATCH 004/171] Move isMultiline: true argument before string content at all callsites The recent IndentedTextWriter refactor moved the `isMultiline` parameter to the FIRST positional position on the new Write/WriteLine overloads (to satisfy the InterpolatedStringHandlerArgument requirement that the named handler argument come after its referenced parameters). This commit updates all 231 callsites across 25 files in the `WinRT.Projection.Writer` to match. Mechanical change: writer.WriteLine($$\"\"\" ...content... \"\"\", isMultiline: true); becomes: writer.WriteLine(isMultiline: true, $$\"\"\" ...content... \"\"\"); No semantic differences. Build passes with 0 warnings, 0 errors. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 8 +- .../Extensions/ProjectionWriterExtensions.cs | 16 +-- .../Factories/AbiClassFactory.cs | 52 +++---- .../Factories/AbiDelegateFactory.cs | 48 +++---- .../Factories/AbiInterfaceFactory.cs | 48 +++---- .../Factories/AbiInterfaceIDicFactory.cs | 48 +++---- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 60 ++++---- .../AbiMethodBodyFactory.MethodsClass.cs | 24 ++-- .../AbiMethodBodyFactory.RcwCaller.cs | 128 +++++++++--------- .../Factories/ClassFactory.cs | 40 +++--- .../ClassMembersFactory.WriteClassMembers.cs | 8 +- ...assMembersFactory.WriteInterfaceMembers.cs | 44 +++--- .../Factories/ComponentFactory.cs | 28 ++-- .../ConstructorFactory.AttributedTypes.cs | 16 +-- .../ConstructorFactory.Composable.cs | 28 ++-- .../ConstructorFactory.FactoryCallbacks.cs | 84 ++++++------ .../Factories/EventTableFactory.cs | 20 +-- .../Factories/MappedInterfaceStubFactory.cs | 32 ++--- .../Factories/MetadataAttributeFactory.cs | 40 +++--- .../Factories/RefModeStubFactory.cs | 8 +- .../Factories/ReferenceImplFactory.cs | 32 ++--- .../Factories/StructEnumMarshallerFactory.cs | 76 +++++------ .../Helpers/IidExpressionGenerator.cs | 20 +-- .../Helpers/ObjRefNameGenerator.cs | 12 +- .../WellKnownInterfaceEntriesEmitter.cs | 4 +- 25 files changed, 462 insertions(+), 462 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 5059b38a5..65be7d75a 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -121,9 +121,9 @@ public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext co MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(writer, context, type); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{accessibility}} enum {{typeName}} : {{enumUnderlyingType}} - """, isMultiline: true); + """); using (writer.WriteBlock()) { foreach (FieldDefinition field in type.Fields) @@ -341,11 +341,11 @@ public static void WriteContract(IndentedTextWriter writer, ProjectionEmitContex string typeName = type.Name?.Value ?? string.Empty; CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{context.Settings.InternalAccessibility}} enum {{typeName}} { } - """, isMultiline: true); + """); } /// diff --git a/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs index 851c19d54..ffb367fa9 100644 --- a/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs @@ -23,7 +23,7 @@ internal static class ProjectionWriterExtensions /// The active emit context (currently unused, but reserved for future per-namespace customization). public void WriteFileHeader(ProjectionEmitContext context) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" //------------------------------------------------------------------------------ // // This file was generated by cswinrt.exe version {{MetadataAttributeFactory.GetVersionString()}} @@ -54,7 +54,7 @@ public void WriteFileHeader(ProjectionEmitContext context) #pragma warning disable CSWINRT3001 // "Type or member '...' is a private implementation detail" #pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type - """, isMultiline: true); + """); } /// @@ -66,10 +66,10 @@ public void WriteBeginProjectedNamespace(ProjectionEmitContext context) { string nsPrefix = context.Settings.Component ? "ABI.Impl." : string.Empty; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" namespace {{nsPrefix}}{{context.CurrentNamespace}} { - """, isMultiline: true); + """); writer.IncreaseIndent(); if (context.Settings.Component) { @@ -97,11 +97,11 @@ public void WriteEndProjectedNamespace(ProjectionEmitContext context) public void WriteBeginAbiNamespace(ProjectionEmitContext context) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" #pragma warning disable CA1416 namespace ABI.{{context.CurrentNamespace}} { - """, isMultiline: true); + """); writer.IncreaseIndent(); context.InAbiNamespace = true; } @@ -115,10 +115,10 @@ namespace ABI.{{context.CurrentNamespace}} public void WriteEndAbiNamespace(ProjectionEmitContext context) { writer.DecreaseIndent(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ } #pragma warning restore CA1416 - """, isMultiline: true); + """); context.InAbiNamespace = false; } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 1cd9e3cad..d7048158e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -82,12 +82,12 @@ internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, Pr } writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static unsafe class {{nameStripped}}Marshaller { public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedType}} value) { - """, isMultiline: true); + """); if (defaultGenericInst is not null) { // Emit the UnsafeAccessor declaration (uses 'object?' since component-mode @@ -101,7 +101,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedT } } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" return WindowsRuntimeInterfaceMarshaller<{{projectedType}}>.ConvertToUnmanaged(value, {{defaultIfaceIid}}); } @@ -110,7 +110,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedT return ({{projectedType}}?) WindowsRuntimeObjectMarshaller.ConvertToManaged(value); } } - """, isMultiline: true); + """); } /// @@ -145,11 +145,11 @@ internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, Proje writer.WriteLine($"[WindowsRuntimeClassName(\"Windows.Foundation.IReference`1<{fullName}>\")]"); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [WindowsRuntimeMetadataTypeName("{{fullName}}")] [WindowsRuntimeMappedType(typeof({{projectedType}}))] file static class {{nameStripped}} {} - """, isMultiline: true); + """); } /// @@ -228,42 +228,42 @@ internal static void WriteClassMarshallerStub(IndentedTextWriter writer, Project bool defaultIfaceIsExclusive = defaultIfaceTd is not null && TypeCategorization.IsExclusiveTo(defaultIfaceTd); // Public *Marshaller class - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static unsafe class {{nameStripped}}Marshaller { public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjected}} value) { - """, isMultiline: true); + """); if (isSealed) { // For projected sealed runtime classes, the RCW type is always unwrappable. - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ if (value is not null) { return WindowsRuntimeComWrappersMarshal.UnwrapObjectReferenceUnsafe(value).AsValue(); } - """, isMultiline: true); + """); } else if (!defaultIfaceIsExclusive && defaultIface is not null) { string defIfaceTypeName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(defaultIface.ToTypeSignature(false)), TypedefNameType.Projected, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (value is IWindowsRuntimeInterface<{{defIfaceTypeName}}> windowsRuntimeInterface) { return windowsRuntimeInterface.GetInterface(); } - """, isMultiline: true); + """); } else { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ if (value is not null) { return value.GetDefaultInterface(); } - """, isMultiline: true); + """); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" return default; } @@ -274,11 +274,11 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjec } file sealed unsafe class {{nameStripped}}ComWrappersMarshallerAttribute : WindowsRuntimeComWrappersMarshallerAttribute - """, isMultiline: true); + """); using (writer.WriteBlock()) { AbiMethodBodyFactory.EmitUnsafeAccessorForDefaultIfaceIfGeneric(writer, context, defaultIface); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public override object CreateObject(void* value, out CreatedWrapperFlags wrapperFlags) { WindowsRuntimeObjectReference valueReference = WindowsRuntimeComWrappersMarshal.CreateObjectReference( @@ -289,7 +289,7 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper return new {{fullProjected}}(valueReference); } - """, isMultiline: true); + """); } writer.WriteLine(); @@ -297,12 +297,12 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper if (isSealed) { // file-scoped *ComWrappersCallback - implements IWindowsRuntimeObjectComWrappersCallback - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" file sealed unsafe class {{nameStripped}}ComWrappersCallback : IWindowsRuntimeObjectComWrappersCallback { - """, isMultiline: true); + """); AbiMethodBodyFactory.EmitUnsafeAccessorForDefaultIfaceIfGeneric(writer, context, defaultIface); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static object CreateObject(void* value, out CreatedWrapperFlags wrapperFlags) { WindowsRuntimeObjectReference valueReference = WindowsRuntimeComWrappersMarshal.CreateObjectReferenceUnsafe( @@ -314,20 +314,20 @@ public static object CreateObject(void* value, out CreatedWrapperFlags wrapperFl return new {{fullProjected}}(valueReference); } } - """, isMultiline: true); + """); } else { // file-scoped *ComWrappersCallback - implements IWindowsRuntimeUnsealedObjectComWrappersCallback string nonProjectedRcn = $"{typeNs}.{nameStripped}"; - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" file sealed unsafe class {{nameStripped}}ComWrappersCallback : IWindowsRuntimeUnsealedObjectComWrappersCallback { - """, isMultiline: true); + """); AbiMethodBodyFactory.EmitUnsafeAccessorForDefaultIfaceIfGeneric(writer, context, defaultIface); // TryCreateObject (non-projected runtime class name match) - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static unsafe bool TryCreateObject( void* value, ReadOnlySpan runtimeClassName, @@ -362,7 +362,7 @@ public static unsafe object CreateObject(void* value, out CreatedWrapperFlags wr return new {{fullProjected}}(valueReference); } } - """, isMultiline: true); + """); } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 1d2f2b33a..c95449c27 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -73,7 +73,7 @@ private static void WriteDelegateImpl(IndentedTextWriter writer, ProjectionEmitC string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" internal static unsafe class {{nameStripped}}Impl { [FixedAddressValueType] @@ -93,7 +93,7 @@ public static nint Vtable [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] private static int Invoke( - """, isMultiline: true); + """); AbiInterfaceFactory.WriteAbiParameterTypesPointer(writer, context, sig, includeParamNames: true); writer.Write(")"); @@ -109,14 +109,14 @@ private static int Invoke( AbiMethodBodyFactory.EmitDoAbiBodyIfSimple(writer, context, sig, projectedDelegateForBody, "Invoke"); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static ref readonly Guid IID { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => ref {{iidExpr}}; } } - """, isMultiline: true); + """); } private static void WriteDelegateVftbl(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) @@ -138,7 +138,7 @@ private static void WriteDelegateVftbl(IndentedTextWriter writer, ProjectionEmit string nameStripped = IdentifierEscaping.StripBackticks(name); writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [StructLayout(LayoutKind.Sequential)] internal unsafe struct {{nameStripped}}Vftbl { @@ -146,12 +146,12 @@ internal unsafe struct {{nameStripped}}Vftbl public delegate* unmanaged[MemberFunction] AddRef; public delegate* unmanaged[MemberFunction] Release; public delegate* unmanaged[MemberFunction]< - """, isMultiline: true); + """); AbiInterfaceFactory.WriteAbiParameterTypesPointer(writer, context, sig); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ , int> Invoke; } - """, isMultiline: true); + """); } private static void WriteNativeDelegate(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) @@ -173,11 +173,11 @@ private static void WriteNativeDelegate(IndentedTextWriter writer, ProjectionEmi string nameStripped = IdentifierEscaping.StripBackticks(name); writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" public static unsafe class {{nameStripped}}NativeDelegate { public static unsafe - """, isMultiline: true); + """); MethodFactory.WriteProjectionReturnType(writer, context, sig); writer.Write($" {nameStripped}Invoke(this WindowsRuntimeObjectReference thisReference"); @@ -211,7 +211,7 @@ private static void WriteDelegateInterfaceEntriesImpl(IndentedTextWriter writer, string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" file static class {{nameStripped}}InterfaceEntriesImpl { [FixedAddressValueType] @@ -223,16 +223,16 @@ file static class {{nameStripped}}InterfaceEntriesImpl Entries.Delegate.Vtable = {{nameStripped}}Impl.Vtable; Entries.DelegateReference.IID = {{iidRefExpr}}; Entries.DelegateReference.Vtable = {{nameStripped}}ReferenceImpl.Vtable; - """, isMultiline: true); + """); writer.IncreaseIndent(); writer.IncreaseIndent(); WellKnownInterfaceEntriesEmitter.EmitDelegateReferenceWellKnownEntries(writer); writer.DecreaseIndent(); writer.DecreaseIndent(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ } } - """, isMultiline: true); + """); } /// @@ -273,7 +273,7 @@ public static void WriteDelegateEventSourceSubclass(IndentedTextWriter writer, P } writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" public sealed unsafe class {{nameStripped}}EventSource : EventSource<{{projectedName}}> { /// @@ -306,7 +306,7 @@ public EventState(void* thisPtr, int index) protected override {{projectedName}} GetEventInvoke() { return ( - """, isMultiline: true); + """); for (int i = 0; i < sig.Parameters.Count; i++) { if (i > 0) @@ -350,12 +350,12 @@ public EventState(void* thisPtr, int index) string raw = sig.Parameters[i].Parameter.Name ?? "p"; writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ); } } } - """, isMultiline: true); + """); } /// @@ -373,7 +373,7 @@ private static void WriteDelegateMarshallerOnly(IndentedTextWriter writer, Proje string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static unsafe class {{nameStripped}}Marshaller { public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjected}} value) @@ -388,7 +388,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjec } #nullable disable } - """, isMultiline: true); + """); } /// @@ -407,7 +407,7 @@ private static void WriteDelegateComWrappersCallback(IndentedTextWriter writer, string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" file abstract unsafe class {{nameStripped}}ComWrappersCallback : IWindowsRuntimeObjectComWrappersCallback { /// @@ -421,7 +421,7 @@ public static object CreateObject(void* value, out CreatedWrapperFlags wrapperFl return new {{fullProjected}}(valueReference.{{nameStripped}}Invoke); } } - """, isMultiline: true); + """); } /// @@ -436,7 +436,7 @@ private static void WriteDelegateComWrappersMarshallerAttribute(IndentedTextWrit string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" internal sealed unsafe class {{nameStripped}}ComWrappersMarshallerAttribute : WindowsRuntimeComWrappersMarshallerAttribute { /// @@ -460,7 +460,7 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper return WindowsRuntimeDelegateMarshaller.UnboxToManaged<{{nameStripped}}ComWrappersCallback>(value, in {{iidRefExpr}})!; } } - """, isMultiline: true); + """); } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index dea45ff2a..776ea6a29 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -209,20 +209,20 @@ public static void WriteInterfaceVftbl(IndentedTextWriter writer, ProjectionEmit string nameStripped = IdentifierEscaping.StripBackticks(name); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [StructLayout(LayoutKind.Sequential)] internal unsafe struct {{nameStripped}}Vftbl - """, isMultiline: true); + """); using (writer.WriteBlock()) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ public delegate* unmanaged[MemberFunction] QueryInterface; public delegate* unmanaged[MemberFunction] AddRef; public delegate* unmanaged[MemberFunction] Release; public delegate* unmanaged[MemberFunction] GetIids; public delegate* unmanaged[MemberFunction] GetRuntimeClassName; public delegate* unmanaged[MemberFunction] GetTrustLevel; - """, isMultiline: true); + """); foreach (MethodDefinition method in type.Methods) { @@ -256,29 +256,29 @@ public static void WriteInterfaceImpl(IndentedTextWriter writer, ProjectionEmitC writer.WriteLine(); writer.WriteLine($"public static unsafe class {nameStripped}Impl"); using IndentedTextWriter.Block __implBlock = writer.WriteBlock(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [FixedAddressValueType] private static readonly {{nameStripped}}Vftbl Vftbl; static {{nameStripped}}Impl() { *(IInspectableVftbl*)Unsafe.AsPointer(ref Vftbl) = *(IInspectableVftbl*)IInspectableImpl.Vtable; - """, isMultiline: true); + """); foreach (MethodDefinition method in type.Methods) { string vm = AbiTypeHelpers.GetVirtualMethodName(type, method); writer.WriteLine($" Vftbl.{vm} = &Do_Abi_{vm};"); } - writer.Write(""" + writer.Write(isMultiline: true, """ } public static ref readonly Guid IID { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => ref - """, isMultiline: true); + """); AbiTypeHelpers.WriteIidGuidReference(writer, context, type); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ; } @@ -287,7 +287,7 @@ public static nint Vtable [MethodImpl(MethodImplOptions.AggressiveInlining)] get => (nint)Unsafe.AsPointer(in Vftbl); } - """, isMultiline: true); + """); writer.WriteLine(); // Do_Abi_* implementations: emit real bodies for simple primitive cases, @@ -385,10 +385,10 @@ void EmitOneDoAbi(MethodDefinition method) EventTableFactory.EmitEventTableField(writer, context, evt, ifaceFullName); } - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] private static unsafe int Do_Abi_{{vm}}( - """, isMultiline: true); + """); WriteAbiParameterTypesPointer(writer, context, sig, includeParamNames: true); writer.Write(")"); @@ -473,44 +473,44 @@ public static void WriteInterfaceMarshaller(IndentedTextWriter writer, Projectio string nameStripped = IdentifierEscaping.StripBackticks(name); writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" #nullable enable public static unsafe class {{nameStripped}}Marshaller { public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(""" + writer.Write(isMultiline: true, """ value) { return WindowsRuntimeInterfaceMarshaller< - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); TypedefNameWriter.WriteTypeParams(writer, type); writer.Write(">.ConvertToUnmanaged(value, "); AbiTypeHelpers.WriteIidGuidReference(writer, context, type); - writer.Write(""" + writer.Write(isMultiline: true, """ ); } public static - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(""" + writer.Write(isMultiline: true, """ ? ConvertToManaged(void* value) { return ( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ?) WindowsRuntimeObjectMarshaller.ConvertToManaged(value); } } #nullable disable - """, isMultiline: true); + """); } /// @@ -616,10 +616,10 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj return; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{(useInternal ? "internal static class " : "public static class ")}}{{nameStripped}}Methods { - """, isMultiline: true); + """); foreach ((TypeDefinition iface, int startSlot, bool segSkipEvents) in segments) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 3d8d4757b..e74f73af1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -204,7 +204,7 @@ internal static void EmitDicShimIObservableMapForwarders(IndentedTextWriter writ string self = $"global::System.Collections.Generic.IDictionary<{keyText}, {valueText}>."; string icoll = $"global::System.Collections.Generic.ICollection>."; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ICollection<{{keyText}}> {{self}}Keys => {{target}}.Keys; ICollection<{{valueText}}> {{self}}Values => {{target}}.Values; int {{icoll}}Count => {{target}}.Count; @@ -225,18 +225,18 @@ internal static void EmitDicShimIObservableMapForwarders(IndentedTextWriter writ bool ICollection>.Remove(KeyValuePair<{{keyText}}, {{valueText}}> item) => {{target}}.Remove(item); IEnumerator> IEnumerable>.GetEnumerator() => {{target}}.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - """, isMultiline: true); + """); // IObservableMap.MapChanged event forwarder. string obsTarget = $"((global::Windows.Foundation.Collections.IObservableMap<{keyText}, {valueText}>)(WindowsRuntimeObject)this)"; string obsSelf = $"global::Windows.Foundation.Collections.IObservableMap<{keyText}, {valueText}>."; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" event global::Windows.Foundation.Collections.MapChangedEventHandler<{{keyText}}, {{valueText}}> {{obsSelf}}MapChanged { add => {{obsTarget}}.MapChanged += value; remove => {{obsTarget}}.MapChanged -= value; } - """, isMultiline: true); + """); } /// @@ -251,7 +251,7 @@ internal static void EmitDicShimIObservableVectorForwarders(IndentedTextWriter w string self = $"global::System.Collections.Generic.IList<{elementText}>."; string icoll = $"global::System.Collections.Generic.ICollection<{elementText}>."; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" int {{icoll}}Count => {{target}}.Count; bool {{icoll}}IsReadOnly => {{target}}.IsReadOnly; {{elementText}} {{self}}this[int index] @@ -269,18 +269,18 @@ internal static void EmitDicShimIObservableVectorForwarders(IndentedTextWriter w bool {{icoll}}Remove({{elementText}} item) => {{target}}.Remove(item); IEnumerator<{{elementText}}> IEnumerable<{{elementText}}>.GetEnumerator() => {{target}}.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - """, isMultiline: true); + """); // IObservableVector.VectorChanged event forwarder. string obsTarget = $"((global::Windows.Foundation.Collections.IObservableVector<{elementText}>)(WindowsRuntimeObject)this)"; string obsSelf = $"global::Windows.Foundation.Collections.IObservableVector<{elementText}>."; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" event global::Windows.Foundation.Collections.VectorChangedEventHandler<{{elementText}}> {{obsSelf}}VectorChanged { add => {{obsTarget}}.VectorChanged += value; remove => {{obsTarget}}.VectorChanged -= value; } - """, isMultiline: true); + """); } /// @@ -365,13 +365,13 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented writer.WriteLine(); writer.Write("event "); TypedefNameWriter.WriteEventType(writer, context, evt); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{ccwIfaceName}}.{{evtName}} { add => (({{ccwIfaceName}})(WindowsRuntimeObject)this).{{evtName}} += value; remove => (({{ccwIfaceName}})(WindowsRuntimeObject)this).{{evtName}} -= value; } - """, isMultiline: true); + """); } } @@ -396,7 +396,7 @@ internal static void EmitDicShimMappedBclForwarders(IndentedTextWriter writer, P case "IBindableVector": // IList covers IList, ICollection, and IEnumerable members. writer.WriteLine(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ int global::System.Collections.ICollection.Count => ((global::System.Collections.IList)(WindowsRuntimeObject)this).Count; bool global::System.Collections.ICollection.IsSynchronized => ((global::System.Collections.IList)(WindowsRuntimeObject)this).IsSynchronized; object global::System.Collections.ICollection.SyncRoot => ((global::System.Collections.IList)(WindowsRuntimeObject)this).SyncRoot; @@ -418,7 +418,7 @@ internal static void EmitDicShimMappedBclForwarders(IndentedTextWriter writer, P void global::System.Collections.IList.RemoveAt(int index) => ((global::System.Collections.IList)(WindowsRuntimeObject)this).RemoveAt(index); IEnumerator IEnumerable.GetEnumerator() => ((global::System.Collections.IList)(WindowsRuntimeObject)this).GetEnumerator(); - """, isMultiline: true); + """); break; case "IBindableIterable": writer.WriteLine(); @@ -460,12 +460,12 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite MethodFactory.WriteProjectionReturnType(writer, context, sig); writer.Write($" {ccwIfaceName}.{mname}("); MethodFactory.WriteParameterList(writer, context, sig); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ) { var _obj = ((WindowsRuntimeObject)this).GetObjectReferenceForInterface(typeof({{ccwIfaceName}}).TypeHandle); - """, isMultiline: true); + """); if (sig.ReturnType is not null) { writer.Write("return "); @@ -477,10 +477,10 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite writer.Write(", "); ClassMembersFactory.WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ); } - """, isMultiline: true); + """); } foreach (PropertyDefinition prop in type.Properties) @@ -490,19 +490,19 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite string propType = InterfaceFactory.WritePropType(context, prop); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" unsafe {{propType}} {{ccwIfaceName}}.{{pname}} { - """, isMultiline: true); + """); if (getter is not null) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" get { var _obj = ((WindowsRuntimeObject)this).GetObjectReferenceForInterface(typeof({{ccwIfaceName}}).TypeHandle); return {{abiClass}}.{{pname}}(_obj); } - """, isMultiline: true); + """); } if (setter is not null) @@ -523,13 +523,13 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite } } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" set { var _obj = ((WindowsRuntimeObject)this).GetObjectReferenceForInterface(typeof({{ccwIfaceName}}).TypeHandle); {{abiClass}}.{{pname}}(_obj, value); } - """, isMultiline: true); + """); } writer.WriteLine("}"); } @@ -542,7 +542,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite writer.WriteLine(); writer.Write("event "); TypedefNameWriter.WriteEventType(writer, context, evt); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{ccwIfaceName}}.{{evtName}} { add @@ -556,7 +556,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite {{abiClass}}.{{evtName}}((WindowsRuntimeObject)this, _obj).Unsubscribe(value); } } - """, isMultiline: true); + """); } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index fb5938e4e..f2e0153b3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -78,10 +78,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(rt!, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt!, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - """, isMultiline: true); + """); writer.WriteLine(); } @@ -108,10 +108,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - """, isMultiline: true); + """); writer.WriteLine(); } @@ -142,10 +142,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection : context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern void ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); - """, isMultiline: true); + """); writer.WriteLine(); } @@ -163,10 +163,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(retSzHoist.BaseType); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern void ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); - """, isMultiline: true); + """); writer.WriteLine(); } @@ -198,10 +198,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { if (returnIsReceiveArrayDoAbi) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" *{{retParamName}} = default; *{{retSizeParamName}} = default; - """, isMultiline: true); + """); } else { @@ -262,11 +262,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" *{{ptr}} = default; *__{{raw}}Size = default; {{elementProjected}}[] __{{raw}} = default; - """, isMultiline: true); + """); } // For each blittable array (PassArray / FillArray) parameter, declare a Span local that @@ -301,19 +301,19 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { // Non-blittable element: InlineArray16 + ArrayPool with size from ABI. writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16<{{elementProjected}}> __{{raw}}_inlineArray); {{elementProjected}}[] __{{raw}}_arrayFromPool = null; Span<{{elementProjected}}> __{{raw}} = __{{raw}}Size <= 16 ? __{{raw}}_inlineArray[..(int)__{{raw}}Size] : (__{{raw}}_arrayFromPool = global::System.Buffers.ArrayPool<{{elementProjected}}>.Shared.Rent((int)__{{raw}}Size)); - """, isMultiline: true); + """); } } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ try { - """, isMultiline: true); + """); // For non-blittable PassArray params (read-only input arrays), emit CopyToManaged_ // via UnsafeAccessor to convert the native ABI buffer into the managed Span the @@ -364,11 +364,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection dataCastExpr = "(void**)" + ptr; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] static extern void CopyToManaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); CopyToManaged_{{raw}}(null, __{{raw}}Size, {{dataCastExpr}}, __{{raw}}); - """, isMultiline: true); + """); } // For generic instance ABI input parameters, emit local UnsafeAccessor delegates and locals @@ -392,11 +392,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string callName = CSharpKeywords.IsKeyword(rawName) ? "@" + rawName : rawName; string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] static extern {{projectedTypeName}} ConvertToManaged_arg_{{rawName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); var __arg_{{rawName}} = ConvertToManaged_arg_{{rawName}}(null, {{callName}}); - """, isMultiline: true); + """); } } @@ -441,10 +441,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { if (i > 0) { - writer.Write(""" + writer.Write(isMultiline: true, """ , - """, isMultiline: true); + """); } ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); @@ -667,11 +667,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection dataCastType = "(" + abiStructName + "*)"; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{dataParamType}}); CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, {{dataCastType}}{{ptr}}); - """, isMultiline: true); + """); } if (rt is not null) @@ -757,14 +757,14 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ return 0; } catch (Exception __exception__) { return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__); } - """, isMultiline: true); + """); // For non-blittable PassArray params, emit finally block with ArrayPool.Shared.Return. bool hasNonBlittableArrayDoAbi = false; @@ -794,10 +794,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (hasNonBlittableArrayDoAbi) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ finally { - """, isMultiline: true); + """); for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; @@ -821,12 +821,12 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (__{{raw}}_arrayFromPool is not null) { global::System.Buffers.ArrayPool<{{elementProjected}}>.Shared.Return(__{{raw}}_arrayFromPool); } - """, isMultiline: true); + """); } writer.WriteLine("}"); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 8e43b0d66..3cc82e069 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -58,10 +58,10 @@ internal static void EmitMethodsClassMembersFor(IndentedTextWriter writer, Proje string mname = method.Name?.Value ?? string.Empty; MethodSignatureInfo sig = new(method); - writer.Write(""" + writer.Write(isMultiline: true, """ [MethodImpl(MethodImplOptions.NoInlining)] public static unsafe - """, isMultiline: true); + """); MethodFactory.WriteProjectionReturnType(writer, context, sig); writer.Write($" {mname}(WindowsRuntimeObjectReference thisReference"); @@ -91,20 +91,20 @@ public static unsafe if (gMethod is not null) { MethodSignatureInfo getSig = new(gMethod); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [MethodImpl(MethodImplOptions.NoInlining)] public static unsafe {{propType}} {{pname}}(WindowsRuntimeObjectReference thisReference) - """, isMultiline: true); + """); EmitAbiMethodBodyIfSimple(writer, context, getSig, methodSlot[gMethod], isNoExcept: propIsNoExcept); } if (sMethod is not null) { MethodSignatureInfo setSig = new(sMethod); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [MethodImpl(MethodImplOptions.NoInlining)] public static unsafe void {{pname}}(WindowsRuntimeObjectReference thisReference, {{InterfaceFactory.WritePropType(context, prop, isSetProperty: true)}} value) - """, isMultiline: true); + """); EmitAbiMethodBodyIfSimple(writer, context, setSig, methodSlot[sMethod], paramNameOverride: "value", isNoExcept: propIsNoExcept); } } @@ -163,7 +163,7 @@ public static unsafe // Emit the per-event ConditionalWeakTable static field. writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" private static ConditionalWeakTable _{{evtName}} { [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -183,10 +183,10 @@ public static unsafe public static {{eventSourceProjectedFull}} {{evtName}}(object thisObject, WindowsRuntimeObjectReference thisReference) { - """, isMultiline: true); + """); if (isGenericEvent && !string.IsNullOrEmpty(eventSourceInteropType)) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.Constructor)] [return: UnsafeAccessorType("{{eventSourceInteropType}}")] static extern object ctor(WindowsRuntimeObjectReference nativeObjectReference, int index); @@ -195,17 +195,17 @@ public static unsafe key: thisObject, valueFactory: static (_, thisReference) => Unsafe.As<{{eventSourceProjectedFull}}>(ctor(thisReference, {{eventSlot.ToString(CultureInfo.InvariantCulture)}})), factoryArgument: thisReference); - """, isMultiline: true); + """); } else { // Non-generic delegate: directly construct. - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" return _{{evtName}}.GetOrAdd( key: thisObject, valueFactory: static (_, thisReference) => new {{eventSourceProjectedFull}}(thisReference, {{eventSlot.ToString(CultureInfo.InvariantCulture)}}), factoryArgument: thisReference); - """, isMultiline: true); + """); } writer.WriteLine(" }"); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 9b7c2232f..1499d2ecc 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -248,11 +248,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec _ = fp.Append(", int"); writer.WriteLine(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ { using WindowsRuntimeObjectReferenceValue thisValue = thisReference.AsValue(); void* ThisPtr = thisValue.GetThisPtrUnsafe(); - """, isMultiline: true); + """); // Declare 'using' marshaller values for ref-type parameters (these need disposing). for (int i = 0; i < sig.Parameters.Count; i++) @@ -283,11 +283,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); using WindowsRuntimeObjectReferenceValue __{{localName}} = ConvertToUnmanaged_{{localName}}(null, {{callName}}); - """, isMultiline: true); + """); } } @@ -410,10 +410,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" uint __{{localName}}_length = default; - """, isMultiline: true); + """); // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. if (sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject()) @@ -473,13 +473,13 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ? "global::ABI.System.Exception" : "nint"; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16<{{storageT}}> __{{localName}}_inlineArray); {{storageT}}[] __{{localName}}_arrayFromPool = null; Span<{{storageT}}> __{{localName}}_span = {{callName}}.Length <= 16 ? __{{localName}}_inlineArray[..{{callName}}.Length] : (__{{localName}}_arrayFromPool = global::System.Buffers.ArrayPool<{{storageT}}>.Shared.Rent({{callName}}.Length)); - """, isMultiline: true); + """); if (szArr.BaseType.IsString() && cat == ParameterCategory.PassArray) { @@ -487,7 +487,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Only required for PassArray (managed -> HSTRING conversion); FillArray's native side // fills HSTRING handles directly into the nint storage. writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16 __{{localName}}_inlineHeaderArray); HStringHeader[] __{{localName}}_headerArrayFromPool = null; Span __{{localName}}_headerSpan = {{callName}}.Length <= 16 @@ -499,17 +499,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec Span __{{localName}}_pinnedHandleSpan = {{callName}}.Length <= 16 ? __{{localName}}_inlinePinnedHandleArray[..{{callName}}.Length] : (__{{localName}}_pinnedHandleArrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - """, isMultiline: true); + """); } } if (returnIsReceiveArray) { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt!; - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ uint __retval_length = default; - """, isMultiline: true); + """); if (retSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSz.BaseType) || retSz.BaseType.IsObject()) { writer.Write("void*"); @@ -634,10 +634,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (needsTryFinally) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ try { - """, isMultiline: true); + """); } string indent = needsTryFinally ? " " : " "; @@ -815,10 +815,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.Write(callName); } } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ) {{indent}}{{new string(' ', fixedNesting * 4)}}{ - """, isMultiline: true); + """); fixedNesting++; // Inside the body: emit HStringMarshaller calls for input string params. for (int i = 0; i < sig.Parameters.Count; i++) @@ -884,13 +884,13 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}HStringArrayMarshaller.ConvertToUnmanagedUnsafe( {{callIndent}} source: {{callName}}, {{callIndent}} hstringHeaders: (HStringHeader*) _{{localName}}_inlineHeaderArray, {{callIndent}} hstrings: __{{localName}}_span, {{callIndent}} pinnedGCHandles: __{{localName}}_pinnedHandleSpan); - """, isMultiline: true); + """); } else { @@ -937,11 +937,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec dataCastType = "(void**)"; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] {{callIndent}}static extern void CopyToUnmanaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{dataParamType}} data); {{callIndent}}CopyToUnmanaged_{{localName}}(null, {{callName}}, (uint){{callName}}.Length, {{dataCastType}}_{{localName}}); - """, isMultiline: true); + """); } } @@ -966,30 +966,30 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" , (uint){{callName}}.Length, _{{localName}} - """, isMultiline: true); + """); continue; } if (cat == ParameterCategory.Out) { string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" , &__{{localName}} - """, isMultiline: true); + """); continue; } if (cat == ParameterCategory.ReceiveArray) { string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" , &__{{localName}}_length, &__{{localName}}_data - """, isMultiline: true); + """); continue; } @@ -1001,25 +1001,25 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (context.AbiTypeShapeResolver.IsComplexStruct(uRefArg)) { // Complex struct 'in' (Ref) param: pass &__local (the marshaled ABI struct). - writer.Write($$""" + writer.Write(isMultiline: true, $$""" , &__{{localName}} - """, isMultiline: true); + """); } else { // 'in T' projected param: pass the pinned pointer. - writer.Write($$""" + writer.Write(isMultiline: true, $$""" , _{{localName}} - """, isMultiline: true); + """); } continue; } - writer.Write(""" + writer.Write(isMultiline: true, """ , - """, isMultiline: true); + """); if (p.Type.IsHResultException()) { writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}"); @@ -1059,17 +1059,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (returnIsReceiveArray) { - writer.Write(""" + writer.Write(isMultiline: true, """ , &__retval_length, &__retval_data - """, isMultiline: true); + """); } else if (rt is not null) { - writer.Write(""" + writer.Write(isMultiline: true, """ , &__retval - """, isMultiline: true); + """); } // Close the vtable call. One less ')' when noexcept (no ThrowExceptionForHR wrap). @@ -1139,11 +1139,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec dataCastType = "(" + abiStructName + "*)"; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] {{callIndent}}static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); {{callIndent}}CopyToManaged_{{localName}}(null, (uint)__{{localName}}_span.Length, {{dataCastType}}_{{localName}}, {{callName}}); - """, isMultiline: true); + """); } // After call: write back Out params to caller's 'out' var. @@ -1168,11 +1168,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{projectedTypeName}} ConvertToManaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); {{callIndent}}{{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}); - """, isMultiline: true); + """); continue; } @@ -1253,11 +1253,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{elementProjected}}[] ConvertToManaged_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); {{callIndent}}{{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); - """, isMultiline: true); + """); } if (rt is not null) @@ -1280,11 +1280,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(retSz.BaseType, TypedefNameType.Projected); _ = elementInteropArg; - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{elementProjected}}[] ConvertToManaged_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); {{callIndent}}return ConvertToManaged_retval(null, __retval_length, __retval_data); - """, isMultiline: true); + """); } else if (returnIsHResultException) { @@ -1308,11 +1308,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(rt, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{projectedTypeName}} ConvertToManaged_retval([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); {{callIndent}}return ConvertToManaged_retval(null, __retval); - """, isMultiline: true); + """); } else { @@ -1374,11 +1374,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (needsTryFinally) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ } finally { - """, isMultiline: true); + """); // Order matches truth: // 0. Complex-struct input param Dispose (e.g. ProfileUsageMarshaller.Dispose(__value)) @@ -1446,12 +1446,12 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // using the correct element type (ABI.System.Exception, not nint). string localNameH = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (__{{localNameH}}_arrayFromPool is not null) { global::System.Buffers.ArrayPool.Shared.Return(__{{localNameH}}_arrayFromPool); } - """, isMultiline: true); + """); continue; } string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); @@ -1464,7 +1464,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // array directly, with no per-element pinned handle / header to release. if (cat == ParameterCategory.PassArray) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" HStringArrayMarshaller.Dispose(__{{localName}}_pinnedHandleSpan); if (__{{localName}}_pinnedHandleArrayFromPool is not null) @@ -1476,17 +1476,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { global::System.Buffers.ArrayPool.Shared.Return(__{{localName}}_headerArrayFromPool); } - """, isMultiline: true); + """); } // Both PassArray and FillArray need the inline-array's nint pool returned. writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (__{{localName}}_arrayFromPool is not null) { global::System.Buffers.ArrayPool.Shared.Return(__{{localName}}_arrayFromPool); } - """, isMultiline: true); + """); } else { @@ -1515,23 +1515,23 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); _ = elementInteropArg; - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] static extern void Dispose_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{disposeDataParamType}} - """, isMultiline: true); + """); if (!disposeDataParamType.EndsWith("data", StringComparison.Ordinal)) { writer.Write(" data"); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ); fixed({{fixedPtrType}} _{{localName}} = __{{localName}}_span) { Dispose_{{localName}}(null, (uint) __{{localName}}_span.Length, {{disposeCastType}}_{{localName}}); } - """, isMultiline: true); + """); } // ArrayPool storage type matches the InlineArray storage (mapped ABI value type @@ -1542,12 +1542,12 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType) : "nint"; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (__{{localName}}_arrayFromPool is not null) { global::System.Buffers.ArrayPool<{{poolStorageT}}>.Shared.Return(__{{localName}}_arrayFromPool); } - """, isMultiline: true); + """); } // 2. Free Out string/object/runtime-class params. @@ -1608,12 +1608,12 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] static extern void Free_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); Free_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); - """, isMultiline: true); + """); } // 4. Free return value (__retval) — emitted last to match truth ordering. @@ -1651,11 +1651,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(retSz.BaseType, TypedefNameType.Projected); _ = elementInteropArg; - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] static extern void Free_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); Free_retval(null, __retval_length, __retval_data); - """, isMultiline: true); + """); } writer.WriteLine(" }"); diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 713c0fe15..78abee3fe 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -402,24 +402,24 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection writer.Write("public static event "); TypedefNameWriter.WriteEventType(writer, context, evt); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{evtName}} { - """, isMultiline: true); + """); if (context.Settings.ReferenceProjection) { // event accessor bodies become 'throw null' in reference projection mode. - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ add => throw null; remove => throw null; - """, isMultiline: true); + """); } else { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" add => {{abiClass}}.{{evtName}}({{objRef}}, {{objRef}}).Subscribe(value); remove => {{abiClass}}.{{evtName}}({{objRef}}, {{objRef}}).Unsubscribe(value); - """, isMultiline: true); + """); } writer.WriteLine("}"); } @@ -547,23 +547,23 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection internal static void WriteStaticFactoryObjRef(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition staticIface, string runtimeClassFullName, string objRefName) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" private static WindowsRuntimeObjectReference {{objRefName}} { - """, isMultiline: true); + """); if (context.Settings.ReferenceProjection) { // the static factory objref getter body is just 'throw null;'. - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ get { throw null; } } - """, isMultiline: true); + """); return; } - writer.Write($$""" + writer.Write(isMultiline: true, $$""" get { var __{{objRefName}} = field; @@ -572,13 +572,13 @@ private static WindowsRuntimeObjectReference {{objRefName}} return __{{objRefName}}; } return field = WindowsRuntimeObjectReference.GetActivationFactory("{{runtimeClassFullName}}", - """, isMultiline: true); + """); ObjRefNameGenerator.WriteIidExpression(writer, context, staticIface); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ); } } - """, isMultiline: true); + """); } /// @@ -635,10 +635,10 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont { string ctorAccess = type.IsSealed ? "internal" : "protected internal"; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{ctorAccess}} {{typeName}}(WindowsRuntimeObjectReference nativeObjectReference) : base(nativeObjectReference) - """, isMultiline: true); + """); using (writer.WriteBlock()) { if (!type.IsSealed) @@ -651,12 +651,12 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont if (defaultIface is not null) { string defaultObjRefName = ObjRefNameGenerator.GetObjRefName(context, defaultIface); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (GetType() == typeof({{typeName}})) { {{defaultObjRefName}} = NativeObjectReference; } - """, isMultiline: true); + """); } } @@ -711,12 +711,12 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont // Conditional finalizer if (gcPressure > 0) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ~{{typeName}}() { GC.RemoveMemoryPressure({{gcPressure.ToString(CultureInfo.InvariantCulture)}}); } - """, isMultiline: true); + """); } // Class members from interfaces (instance methods, properties, events). diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index fac644c02..d61214be0 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -40,19 +40,19 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo if (s.HasGetter && s.GetterIsGeneric && !string.IsNullOrEmpty(s.GetterGenericInteropType)) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{kvp.Key}}")] static extern {{s.GetterPropTypeText}} {{s.GetterGenericAccessorName}}([UnsafeAccessorType("{{s.GetterGenericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference); - """, isMultiline: true); + """); } if (s.HasSetter && s.SetterIsGeneric && !string.IsNullOrEmpty(s.SetterGenericInteropType)) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{kvp.Key}}")] static extern void {{s.SetterGenericAccessorName}}([UnsafeAccessorType("{{s.SetterGenericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference, {{s.SetterPropTypeText}} value); - """, isMultiline: true); + """); } writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 312267080..b3abbfefa 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -100,12 +100,12 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr writer.WriteLine(); writer.Write("WindowsRuntimeObjectReferenceValue IWindowsRuntimeInterface<"); WriteInterfaceTypeNameForCcw(writer, context, substitutedInterface); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" >.GetInterface() { return {{giObjRefName}}.AsValue(); } - """, isMultiline: true); + """); } else if (impl.IsDefaultInterface() && !classType.IsSealed) { @@ -134,12 +134,12 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr writer.Write("new "); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" WindowsRuntimeObjectReferenceValue GetDefaultInterface() { return {{giObjRefName}}.AsValue(); } - """, isMultiline: true); + """); } // For mapped interfaces with custom members output (e.g. IClosable -> IDisposable, IMap`2 @@ -316,10 +316,10 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // Emit UnsafeAccessor static extern + body that dispatches through it. string accessorName = genericParentEncoded + "_" + name; writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{name}}")] static extern - """, isMultiline: true); + """); MethodFactory.WriteProjectionReturnType(writer, context, sig); writer.Write($" {accessorName}([UnsafeAccessorType(\"{genericInteropType}\")] object _, WindowsRuntimeObjectReference thisReference"); for (int i = 0; i < sig.Parameters.Count; i++) @@ -534,29 +534,29 @@ static extern if (!context.Settings.ReferenceProjection && inlineEventSourceField) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" private {{eventSourceTypeFull}} _eventSource_{{name}} { get { - """, isMultiline: true); + """); if (isGenericEvent && !string.IsNullOrEmpty(eventSourceInteropType)) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.Constructor)] [return: UnsafeAccessorType("{{eventSourceInteropType}}")] static extern object ctor(WindowsRuntimeObjectReference nativeObjectReference, int index); - """, isMultiline: true); + """); writer.WriteLine(); } - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [MethodImpl(MethodImplOptions.NoInlining)] {{eventSourceTypeFull}} MakeEventSource() { _ = global::System.Threading.Interlocked.CompareExchange( location1: ref field, value: - """, isMultiline: true); + """); if (isGenericEvent) { writer.Write($"Unsafe.As<{eventSourceTypeFull}>(ctor({objRef}, {vtableIndex.ToString(CultureInfo.InvariantCulture)}))"); @@ -566,7 +566,7 @@ static extern writer.Write($"new {eventSourceTypeFull}({objRef}, {vtableIndex.ToString(CultureInfo.InvariantCulture)})"); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ , comparand: null); @@ -576,7 +576,7 @@ static extern return field ?? MakeEventSource(); } } - """, isMultiline: true); + """); } // Emit the public/protected event with Subscribe/Unsubscribe. @@ -590,23 +590,23 @@ static extern writer.Write($"{access}{methodSpec}event "); TypedefNameWriter.WriteEventType(writer, context, evt, currentInstance); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{name}} { - """, isMultiline: true); + """); if (context.Settings.ReferenceProjection) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ add => throw null; remove => throw null; - """, isMultiline: true); + """); } else if (inlineEventSourceField) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" add => _eventSource_{{name}}.Subscribe(value); remove => _eventSource_{{name}}.Unsubscribe(value); - """, isMultiline: true); + """); } else { @@ -615,10 +615,10 @@ static extern // inline_event_source_field is false (the default helper-based path). // Example: Simple.Event0 (on ISimple5) becomes // add => global::ABI.test_component_fast.ISimpleMethods.Event0((WindowsRuntimeObject)this, _objRef_test_component_fast_ISimple).Subscribe(value); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" add => {{abiClass}}.{{name}}((WindowsRuntimeObject)this, {{objRef}}).Subscribe(value); remove => {{abiClass}}.{{name}}((WindowsRuntimeObject)this, {{objRef}}).Unsubscribe(value); - """, isMultiline: true); + """); } writer.WriteLine("}"); } diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 1cbe248be..88a686adf 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -79,7 +79,7 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo TypedefNameWriter.WriteTypeParams(writer, iface); } writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" { static {{factoryTypeName}}() { @@ -97,7 +97,7 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo public object ActivateInstance() { - """, isMultiline: true); + """); if (isActivatable) { writer.Write($"return new {projectedTypeName}();"); @@ -223,19 +223,19 @@ private static void WriteStaticFactoryProperty(IndentedTextWriter writer, Projec writer.WriteLine(); writer.Write("public "); WriteFactoryPropertyType(writer, context, prop); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{propName}} { - """, isMultiline: true); + """); if (getter is not null) { writer.WriteLine($"get => {projectedTypeName}.{propName};"); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" set => {{projectedTypeName}}.{{propName}} = value; } - """, isMultiline: true); + """); } /// @@ -253,13 +253,13 @@ private static void WriteStaticFactoryEvent(IndentedTextWriter writer, Projectio TypedefNameWriter.WriteTypeName(writer, context, evtSemantics, TypedefNameType.Projected, false); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{evtName}} { add => {{projectedTypeName}}.{{evtName}} += value; remove => {{projectedTypeName}}.{{evtName}} -= value; } - """, isMultiline: true); + """); } private static void WriteFactoryReturnType(IndentedTextWriter writer, ProjectionEmitContext context, MethodDefinition method) @@ -331,7 +331,7 @@ public static void WriteModuleActivationFactory(IndentedTextWriter writer, IRead foreach (KeyValuePair> kv in typesByModule) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" namespace ABI.{{kv.Key}} { public static class ManagedExports @@ -340,7 +340,7 @@ public static class ManagedExports { switch (activatableClassId) { - """, isMultiline: true); + """); // Sort by the type's metadata token / row index so cases appear in WinMD declaration order. List orderedTypes = [.. kv.Value]; orderedTypes.Sort((a, b) => @@ -352,19 +352,19 @@ public static class ManagedExports foreach (TypeDefinition type in orderedTypes) { (string ns, string name) = type.Names(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" case "{{ns}}.{{name}}": return global::ABI.Impl.{{ns}}.{{IdentifierEscaping.StripBackticks(name)}}ServerActivationFactory.Make(); - """, isMultiline: true); + """); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ default: return null; } } } } - """, isMultiline: true); + """); } } } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 1d89c7a83..8f75453bf 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -54,7 +54,7 @@ public static void WriteAttributedTypes(IndentedTextWriter writer, ProjectionEmi else { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" { get { @@ -66,7 +66,7 @@ public static void WriteAttributedTypes(IndentedTextWriter writer, ProjectionEmi return field = WindowsRuntimeObjectReference.GetActivationFactory("{{fullName}}"); } } - """, isMultiline: true); + """); } } @@ -127,10 +127,10 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio writer.Write($"public unsafe {typeName}("); MethodFactory.WriteParameterList(writer, context, sig); - writer.Write(""" + writer.Write(isMultiline: true, """ ) :base( - """, isMultiline: true); + """); if (sig.Parameters.Count == 0) { writer.Write("default"); @@ -151,10 +151,10 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio writer.Write("))"); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ) { - """, isMultiline: true); + """); if (gcPressure > 0) { writer.WriteLine($"GC.AddMemoryPressure({gcPressure.ToString(CultureInfo.InvariantCulture)});"); @@ -183,11 +183,11 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio string defaultIfaceIid = GetDefaultInterfaceIid(context, classType); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public {{typeName}}() :base(default(WindowsRuntimeActivationTypes.DerivedSealed), {{objRefName}}, {{defaultIfaceIid}}, {{GetMarshalingTypeName(classType)}}) { - """, isMultiline: true); + """); if (gcPressure > 0) { writer.WriteLine($"GC.AddMemoryPressure({gcPressure.ToString(CultureInfo.InvariantCulture)});"); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 58093796b..8412d1d28 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -95,10 +95,10 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); } - writer.Write(""" + writer.Write(isMultiline: true, """ ) :base( - """, isMultiline: true); + """); if (isParameterless) { // base(default(WindowsRuntimeActivationTypes.DerivedComposed), , , ) @@ -121,17 +121,17 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec writer.Write("))"); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ) - """, isMultiline: true); + """); using (writer.WriteBlock()) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (GetType() == typeof({{typeName}})) { {{defaultIfaceObjRef}} = NativeObjectReference; } - """, isMultiline: true); + """); if (gcPressure > 0) { @@ -165,10 +165,10 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec // 1. WindowsRuntimeActivationTypes.DerivedComposed writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" protected {{typeName}}(WindowsRuntimeActivationTypes.DerivedComposed _, WindowsRuntimeObjectReference activationFactoryObjectReference, in Guid iid, CreateObjectReferenceMarshalingType marshalingType) :base(_, activationFactoryObjectReference, in iid, marshalingType) - """, isMultiline: true); + """); using (writer.WriteBlock()) { if (!string.IsNullOrEmpty(gcPressureBody)) @@ -178,10 +178,10 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec } writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" protected {{typeName}}(WindowsRuntimeActivationTypes.DerivedSealed _, WindowsRuntimeObjectReference activationFactoryObjectReference, in Guid iid, CreateObjectReferenceMarshalingType marshalingType) :base(_, activationFactoryObjectReference, in iid, marshalingType) - """, isMultiline: true); + """); using (writer.WriteBlock()) { if (!string.IsNullOrEmpty(gcPressureBody)) @@ -191,10 +191,10 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec } writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" protected {{typeName}}(WindowsRuntimeActivationFactoryCallback.DerivedComposed activationFactoryCallback, in Guid iid, CreateObjectReferenceMarshalingType marshalingType, WindowsRuntimeActivationArgsReference additionalParameters) :base(activationFactoryCallback, in iid, marshalingType, additionalParameters) - """, isMultiline: true); + """); using (writer.WriteBlock()) { if (!string.IsNullOrEmpty(gcPressureBody)) @@ -204,10 +204,10 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec } writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" protected {{typeName}}(WindowsRuntimeActivationFactoryCallback.DerivedSealed activationFactoryCallback, in Guid iid, CreateObjectReferenceMarshalingType marshalingType, WindowsRuntimeActivationArgsReference additionalParameters) :base(activationFactoryCallback, in iid, marshalingType, additionalParameters) - """, isMultiline: true); + """); using (writer.WriteBlock()) { if (!string.IsNullOrEmpty(gcPressureBody)) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index f1766cefc..145335aca 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -40,10 +40,10 @@ private static void EmitFactoryArgsStruct(IndentedTextWriter writer, ProjectionE MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ) { - """, isMultiline: true); + """); for (int i = 0; i < count; i++) { ParameterInfo p = sig.Parameters[i]; @@ -80,35 +80,35 @@ private static void EmitFactoryCallbackClass(IndentedTextWriter writer, Projecti ? "WindowsRuntimeActivationFactoryCallback.DerivedComposed" : "WindowsRuntimeActivationFactoryCallback.DerivedSealed"; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" private sealed class {{callbackName}} : {{baseClass}} { public static readonly {{callbackName}} Instance = new(); [MethodImpl(MethodImplOptions.NoInlining)] - """, isMultiline: true); + """); if (isComposable) { // Composable Invoke signature is multi-line and includes baseInterface (in) + // innerInterface (out). - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ public override unsafe void Invoke( WindowsRuntimeActivationArgsReference additionalParameters, WindowsRuntimeObject baseInterface, out void* innerInterface, out void* retval) { - """, isMultiline: true); + """); } else { // Sealed Invoke signature is multi-line.. - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ public override unsafe void Invoke( WindowsRuntimeActivationArgsReference additionalParameters, out void* retval) { - """, isMultiline: true); + """); } // Invoke body is just 'throw null;' (no factory dispatch, no marshalling). @@ -118,11 +118,11 @@ public override unsafe void Invoke( return; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" using WindowsRuntimeObjectReferenceValue activationFactoryValue = {{factoryObjRefName}}.AsValue(); void* ThisPtr = activationFactoryValue.GetThisPtrUnsafe(); ref readonly {{argsName}} args = ref additionalParameters.GetValueRefUnsafe<{{argsName}}>(); - """, isMultiline: true); + """); // Bind each arg from the args struct to a local of its ABI-marshalable input type. // Bind arg locals. @@ -177,11 +177,11 @@ public override unsafe void Invoke( string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); using WindowsRuntimeObjectReferenceValue __{{raw}} = ConvertToUnmanaged_{{raw}}(null, {{pname}}); - """, isMultiline: true); + """); } // For runtime class / object params, emit `using WindowsRuntimeObjectReferenceValue __ = ...ConvertToUnmanaged();` @@ -212,10 +212,10 @@ public override unsafe void Invoke( // using WindowsRuntimeObjectReferenceValue __baseInterface = WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(baseInterface); if (isComposable) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ using WindowsRuntimeObjectReferenceValue __baseInterface = WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(baseInterface); void* __innerInterface = default; - """, isMultiline: true); + """); } // For mapped value-type params (DateTime, TimeSpan), emit ABI local + marshaller conversion. @@ -279,18 +279,18 @@ public override unsafe void Invoke( string raw = p.Parameter.Name ?? "param"; string callName = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16 __{{raw}}_inlineArray); nint[] __{{raw}}_arrayFromPool = null; Span __{{raw}}_span = {{callName}}.Length <= 16 ? __{{raw}}_inlineArray[..{{callName}}.Length] : (__{{raw}}_arrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - """, isMultiline: true); + """); if (szArr.BaseType.IsString()) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16 __{{raw}}_inlineHeaderArray); HStringHeader[] __{{raw}}_headerArrayFromPool = null; Span __{{raw}}_headerSpan = {{callName}}.Length <= 16 @@ -302,7 +302,7 @@ public override unsafe void Invoke( Span __{{raw}}_pinnedHandleSpan = {{callName}}.Length <= 16 ? __{{raw}}_inlinePinnedHandleArray[..{{callName}}.Length] : (__{{raw}}_pinnedHandleArrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - """, isMultiline: true); + """); } } @@ -310,10 +310,10 @@ public override unsafe void Invoke( if (hasNonBlittableArray) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ try { - """, isMultiline: true); + """); } string baseIndent = hasNonBlittableArray ? " " : " "; @@ -409,10 +409,10 @@ public override unsafe void Invoke( writer.Write(pname); } } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ) {{indent}}{ - """, isMultiline: true); + """); fixedNesting = 1; // Inside the block: emit HStringMarshaller.ConvertToUnmanagedUnsafe for each // string input. The HStringReference local lives stack-only. @@ -460,24 +460,24 @@ public override unsafe void Invoke( if (szArr.BaseType.IsString()) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}HStringArrayMarshaller.ConvertToUnmanagedUnsafe( {{callIndent}} source: {{pname}}, {{callIndent}} hstringHeaders: (HStringHeader*) _{{raw}}_inlineHeaderArray, {{callIndent}} hstrings: __{{raw}}_span, {{callIndent}} pinnedGCHandles: __{{raw}}_pinnedHandleSpan); - """, isMultiline: true); + """); } else { string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); _ = elementInteropArg; - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] {{callIndent}}static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, void** data); {{callIndent}}CopyToUnmanaged_{{raw}}(null, {{pname}}, (uint){{pname}}.Length, (void**)_{{raw}}); - """, isMultiline: true); + """); } } @@ -510,10 +510,10 @@ public override unsafe void Invoke( ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); string raw = p.Parameter.Name ?? "param"; string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; - writer.Write(""" + writer.Write(isMultiline: true, """ , - """, isMultiline: true); + """); if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) { writer.Write($"(uint){pname}.Length, _{raw}"); @@ -567,16 +567,16 @@ public override unsafe void Invoke( if (isComposable) { // Pass __baseInterface.GetThisPtrUnsafe() and &__innerInterface. - writer.Write(""" + writer.Write(isMultiline: true, """ , __baseInterface.GetThisPtrUnsafe(), &__innerInterface - """, isMultiline: true); + """); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ , &__retval)); - """, isMultiline: true); + """); if (isComposable) { writer.WriteLine($"{callIndent}innerInterface = __innerInterface;"); @@ -594,11 +594,11 @@ public override unsafe void Invoke( // Close try and emit finally with cleanup for non-blittable PassArray params. if (hasNonBlittableArray) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ } finally { - """, isMultiline: true); + """); for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; @@ -624,7 +624,7 @@ public override unsafe void Invoke( if (szArr.BaseType.IsString()) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" HStringArrayMarshaller.Dispose(__{{raw}}_pinnedHandleSpan); if (__{{raw}}_pinnedHandleArrayFromPool is not null) @@ -636,14 +636,14 @@ public override unsafe void Invoke( { global::System.Buffers.ArrayPool.Shared.Return(__{{raw}}_headerArrayFromPool); } - """, isMultiline: true); + """); } else { string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); _ = elementInteropArg; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] static extern void Dispose_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, void** data); @@ -651,23 +651,23 @@ public override unsafe void Invoke( { Dispose_{{raw}}(null, (uint) __{{raw}}_span.Length, (void**)_{{raw}}); } - """, isMultiline: true); + """); } writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" if (__{{raw}}_arrayFromPool is not null) { global::System.Buffers.ArrayPool.Shared.Return(__{{raw}}_arrayFromPool); } - """, isMultiline: true); + """); } writer.WriteLine(" }"); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ } } - """, isMultiline: true); + """); } /// diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index f4c459ced..f22023b05 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -28,7 +28,7 @@ internal static void EmitEventTableField(IndentedTextWriter writer, ProjectionEm string evtType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" private static ConditionalWeakTable<{{ifaceFullName}}, EventRegistrationTokenTable<{{evtType}}>> _{{evName}} { [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -45,7 +45,7 @@ internal static void EmitEventTableField(IndentedTextWriter writer, ProjectionEm return global::System.Threading.Volatile.Read(in field) ?? MakeTable(); } } - """, isMultiline: true); + """); } /// @@ -66,23 +66,23 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit bool isGeneric = evtTypeSig is GenericInstanceTypeSignature; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" { *{{cookieName}} = default; try { var __this = ComInterfaceDispatch.GetInstance<{{ifaceFullName}}>((ComInterfaceDispatch*)thisPtr); - """, isMultiline: true); + """); if (isGeneric) { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(evtTypeSig, TypedefNameType.ABI) + ", WinRT.Interop"; string projectedTypeName = MethodFactory.WriteProjectedSignature(context, evtTypeSig, false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] static extern {{projectedTypeName}} ConvertToManaged([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); var __handler = ConvertToManaged(null, {{handlerRef}}); - """, isMultiline: true); + """); } else { @@ -91,7 +91,7 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit writer.WriteLine($"Marshaller.ConvertToManaged({handlerRef});"); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" *{{cookieName}} = _{{evName}}.GetOrCreateValue(__this).AddEventHandler(__handler); __this.{{evName}} += __handler; return 0; @@ -101,7 +101,7 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__); } } - """, isMultiline: true); + """); } /// @@ -114,7 +114,7 @@ internal static void EmitDoAbiRemoveEvent(IndentedTextWriter writer, ProjectionE string tokenRef = CSharpKeywords.IsKeyword(tokenRawName) ? "@" + tokenRawName : tokenRawName; writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" { try { @@ -130,6 +130,6 @@ internal static void EmitDoAbiRemoveEvent(IndentedTextWriter writer, ProjectionE return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__); } } - """, isMultiline: true); + """); } } diff --git a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs index e904a4f8c..d44479ef2 100644 --- a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs @@ -94,18 +94,18 @@ public static void WriteMappedInterfaceStubs(IndentedTextWriter writer, Projecti break; case "IBindableIterator": writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public bool MoveNext() => global::ABI.System.Collections.IEnumeratorMethods.MoveNext({{objRefName}}); public void Reset() => throw new NotSupportedException(); public object Current => global::ABI.System.Collections.IEnumeratorMethods.Current({{objRefName}}); - """, isMultiline: true); + """); break; case "IBindableVector": EmitNonGenericList(writer, objRefName); break; case "INotifyDataErrorInfo": writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public global::System.Collections.IEnumerable GetErrors(string propertyName) => global::ABI.System.ComponentModel.INotifyDataErrorInfoMethods.GetErrors({{objRefName}}, propertyName); public bool HasErrors {get => global::ABI.System.ComponentModel.INotifyDataErrorInfoMethods.HasErrors({{objRefName}}); } public event global::System.EventHandler ErrorsChanged @@ -113,7 +113,7 @@ public static void WriteMappedInterfaceStubs(IndentedTextWriter writer, Projecti add => global::ABI.System.ComponentModel.INotifyDataErrorInfoMethods.ErrorsChanged(this, {{objRefName}}).Subscribe(value); remove => global::ABI.System.ComponentModel.INotifyDataErrorInfoMethods.ErrorsChanged(this, {{objRefName}}).Unsubscribe(value); } - """, isMultiline: true); + """); break; } } @@ -162,13 +162,13 @@ private static void EmitGenericEnumerator(IndentedTextWriter writer, ProjectionE EmitUnsafeAccessor(writer, "MoveNext", "bool", $"{prefix}MoveNext", interopType, ""); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public bool MoveNext() => {{prefix}}MoveNext(null, {{objRefName}}); public void Reset() => throw new NotSupportedException(); public void Dispose() {} public {{t}} Current => {{prefix}}Current(null, {{objRefName}}); object global::System.Collections.IEnumerator.Current => Current!; - """, isMultiline: true); + """); } private static void EmitDictionary(IndentedTextWriter writer, ProjectionEmitContext context, List args, List argSigs, string objRefName) @@ -216,7 +216,7 @@ private static void EmitDictionary(IndentedTextWriter writer, ProjectionEmitCont // Public member emission order matches the WinRT IMap vtable order, NOT alphabetical. // GetEnumerator is NOT emitted here -- it's handled separately by IIterable's own // EmitGenericEnumerable invocation. - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public ICollection<{{k}}> Keys => {{prefix}}Keys(null, {{objRefName}}); public ICollection<{{v}}> Values => {{prefix}}Values(null, {{objRefName}}); public int Count => {{prefix}}Count(null, {{objRefName}}); @@ -235,7 +235,7 @@ private static void EmitDictionary(IndentedTextWriter writer, ProjectionEmitCont public bool Contains({{kv}} item) => {{prefix}}Contains(null, {{objRefName}}, item); public void CopyTo({{kv}}[] array, int arrayIndex) => {{prefix}}CopyTo(null, {{objRefName}}, {{enumerableObjRefName}}, array, arrayIndex); bool ICollection<{{kv}}>.Remove({{kv}} item) => {{prefix}}Remove(null, {{objRefName}}, item); - """, isMultiline: true); + """); } private static void EmitReadOnlyDictionary(IndentedTextWriter writer, ProjectionEmitContext context, List args, List argSigs, string objRefName) @@ -293,11 +293,11 @@ private static void EmitReadOnlyList(IndentedTextWriter writer, ProjectionEmitCo // GetEnumerator is NOT emitted here -- it's handled separately by IIterable's // EmitGenericEnumerable invocation. writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [global::System.Runtime.CompilerServices.IndexerName("ReadOnlyListItem")] public {{t}} this[int index] => {{prefix}}Item(null, {{objRefName}}, index); public int Count => {{prefix}}Count(null, {{objRefName}}); - """, isMultiline: true); + """); } /// @@ -348,7 +348,7 @@ private static void EmitList(IndentedTextWriter writer, ProjectionEmitContext co // Public member emission order matches the WinRT IVector vtable order mapped to IList, // NOT alphabetical. GetEnumerator is NOT emitted here -- it's handled separately by IIterable's // own EmitGenericEnumerable invocation. - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public int Count => {{prefix}}Count(null, {{objRefName}}); public bool IsReadOnly => false; @@ -366,7 +366,7 @@ private static void EmitList(IndentedTextWriter writer, ProjectionEmitContext co public bool Contains({{t}} item) => {{prefix}}Contains(null, {{objRefName}}, item); public void CopyTo({{t}}[] array, int arrayIndex) => {{prefix}}CopyTo(null, {{objRefName}}, array, arrayIndex); public bool Remove({{t}} item) => {{prefix}}Remove(null, {{objRefName}}, item); - """, isMultiline: true); + """); } /// @@ -375,17 +375,17 @@ private static void EmitList(IndentedTextWriter writer, ProjectionEmitContext co /// private static void EmitUnsafeAccessor(IndentedTextWriter writer, string accessName, string returnType, string functionName, string interopType, string extraParams) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{accessName}}")] static extern {{returnType}} {{functionName}}([UnsafeAccessorType("{{interopType}}")] object _, WindowsRuntimeObjectReference objRef{{extraParams}}); - """, isMultiline: true); + """); writer.WriteLine(); } private static void EmitNonGenericList(IndentedTextWriter writer, string objRefName) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" [global::System.Runtime.CompilerServices.IndexerName("NonGenericListItem")] public object this[int index] { @@ -405,7 +405,7 @@ public object this[int index] public void Remove(object value) => global::ABI.System.Collections.IListMethods.Remove({{objRefName}}, value); public void RemoveAt(int index) => global::ABI.System.Collections.IListMethods.RemoveAt({{objRefName}}, index); public void CopyTo(Array array, int index) => global::ABI.System.Collections.IListMethods.CopyTo({{objRefName}}, array, index); - """, isMultiline: true); + """); // GetEnumerator is NOT emitted here -- it's handled separately by IBindableIterable's // EmitNonGenericEnumerable invocation. } diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 5dedfc9a5..5abdda07b 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -69,7 +69,7 @@ internal static string GetVersionString() /// The writer to emit the banner to. public static void WriteFileHeader(IndentedTextWriter writer) { - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" //------------------------------------------------------------------------------ // // This file was generated by cswinrt.exe version {{GetVersionString()}} @@ -78,7 +78,7 @@ public static void WriteFileHeader(IndentedTextWriter writer) // the code is regenerated. // //------------------------------------------------------------------------------ - """, isMultiline: true); + """); } /// @@ -209,11 +209,11 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [assembly: TypeMap( value: "{{projectionName}}", target: typeof( - """, isMultiline: true); + """); if (context.Settings.Component) { TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); @@ -224,19 +224,19 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent writer.Write(projectionName); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ), trimTarget: typeof({{projectionName}}))] - """, isMultiline: true); + """); if (context.Settings.Component) { writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [assembly: TypeMapAssociation( source: typeof({{projectionName}}), proxy: typeof( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); TypedefNameWriter.WriteTypeParams(writer, type); writer.WriteLine("))]"); @@ -257,10 +257,10 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); writer.WriteLine(); - writer.Write(""" + writer.Write(isMultiline: true, """ [assembly: TypeMap( value: " - """, isMultiline: true); + """); if (isValueType) { writer.Write($"Windows.Foundation.IReference`1<{projectionName}>"); @@ -270,10 +270,10 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe writer.Write(projectionName); } - writer.Write(""" + writer.Write(isMultiline: true, """ ", target: typeof( - """, isMultiline: true); + """); if (context.Settings.Component) { TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); @@ -284,10 +284,10 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe writer.Write(projectionName); } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" ), trimTarget: typeof({{projectionName}}))] - """, isMultiline: true); + """); // For non-interface, non-struct authored types, emit proxy association. TypeCategory cat = TypeCategorization.GetCategory(type); @@ -295,11 +295,11 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe if (cat is not (TypeCategory.Interface or TypeCategory.Struct) && context.Settings.Component) { writer.WriteLine(); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [assembly: TypeMapAssociation( source: typeof({{projectionName}}), proxy: typeof( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); TypedefNameWriter.WriteTypeParams(writer, type); writer.WriteLine("))]"); @@ -330,16 +330,16 @@ public static void WriteWinRTIdicTypeMapGroupAssemblyAttribute(IndentedTextWrite } writer.WriteLine(); - writer.Write(""" + writer.Write(isMultiline: true, """ [assembly: TypeMapAssociation( source: typeof( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(""" + writer.Write(isMultiline: true, """ ), proxy: typeof( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); TypedefNameWriter.WriteTypeParams(writer, type); writer.WriteLine("))]"); diff --git a/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs b/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs index 518e09a17..64ccad567 100644 --- a/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs @@ -20,14 +20,14 @@ internal static class RefModeStubFactory public static void EmitRefModeObjRefGetterBody(IndentedTextWriter writer) { writer.WriteLine(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ { get { throw null; } } - """, isMultiline: true); + """); } /// @@ -49,10 +49,10 @@ public static void EmitSyntheticPrivateCtor(IndentedTextWriter writer, string ty /// The writer to emit to. public static void EmitRefModeInvokeBody(IndentedTextWriter writer) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ throw null; } } - """, isMultiline: true); + """); } } diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 99b97a9e8..7f43d20c7 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -30,7 +30,7 @@ public static void WriteReferenceImpl(IndentedTextWriter writer, ProjectionEmitC bool blittable = AbiTypeHelpers.IsTypeBlittable(context.Cache, type); writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" {{visibility}} static unsafe class {{nameStripped}}ReferenceImpl { [FixedAddressValueType] @@ -49,7 +49,7 @@ public static nint Vtable } [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] - """, isMultiline: true); + """); bool isBlittableStructType = blittable && TypeCategorization.GetCategory(type) == TypeCategory.Struct; bool isNonBlittableStructType = !blittable && TypeCategorization.GetCategory(type) == TypeCategory.Struct; @@ -58,7 +58,7 @@ public static nint Vtable { // For blittable types and blittable structs: direct memcpy via C# struct assignment. // Even bool/char fields work because their managed layout matches the WinRT ABI. - writer.Write(""" + writer.Write(isMultiline: true, """ public static int get_Value(void* thisPtr, void* result) { if (result is null) @@ -69,14 +69,14 @@ public static int get_Value(void* thisPtr, void* result) try { var value = ( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.Write(""" + writer.Write(isMultiline: true, """ )(ComInterfaceDispatch.GetInstance((ComInterfaceDispatch*)thisPtr)); *( - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ *)result = value; return 0; } @@ -85,7 +85,7 @@ public static int get_Value(void* thisPtr, void* result) return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(e); } } - """, isMultiline: true); + """); } else if (isNonBlittableStructType) { @@ -93,7 +93,7 @@ public static int get_Value(void* thisPtr, void* result) // (ABI) struct value into the result pointer. string projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); string abiName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, type.ToTypeSignature()); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static int get_Value(void* thisPtr, void* result) { if (result is null) @@ -113,13 +113,13 @@ public static int get_Value(void* thisPtr, void* result) return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(e); } } - """, isMultiline: true); + """); } else if (TypeCategorization.GetCategory(type) is TypeCategory.Class or TypeCategory.Delegate) { // Non-blittable runtime class / delegate: marshal via Marshaller and detach. string projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static int get_Value(void* thisPtr, void* result) { if (result is null) @@ -139,7 +139,7 @@ public static int get_Value(void* thisPtr, void* result) return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(e); } } - """, isMultiline: true); + """); } else { @@ -152,18 +152,18 @@ public static int get_Value(void* thisPtr, void* result) // IID property: 'public static ref readonly Guid IID' pointing at the reference type's IID. writer.WriteLine(); - writer.Write(""" + writer.Write(isMultiline: true, """ public static ref readonly Guid IID { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => ref global::ABI.InterfaceIIDs. - """, isMultiline: true); + """); IidExpressionGenerator.WriteIidReferenceGuidPropertyName(writer, context, type); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ; } } - """, isMultiline: true); + """); writer.WriteLine(); } } diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 8a76a6670..80f8088c8 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -65,10 +65,10 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P isComplexStruct = false; } - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" public static unsafe class {{nameStripped}}Marshaller { - """, isMultiline: true); + """); if (isComplexStruct) { @@ -77,11 +77,11 @@ public static unsafe class {{nameStripped}}Marshaller TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); writer.Write(" ConvertToUnmanaged("); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ value) { return new() { - """, isMultiline: true); + """); bool first = true; foreach (FieldDefinition field in type.Fields) { @@ -134,11 +134,11 @@ public static unsafe class {{nameStripped}}Marshaller } } writer.WriteLine(); - writer.Write(""" + writer.Write(isMultiline: true, """ }; } public static - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); writer.Write(" ConvertToManaged("); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); @@ -147,11 +147,11 @@ public static // - In non-component mode: emit positional constructor (matches the auto-generated // primary constructor on projected struct types). bool useObjectInitializer = context.Settings.Component; - writer.Write(""" + writer.Write(isMultiline: true, """ value) { return new - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); writer.WriteLine(useObjectInitializer ? "(){" : "("); first = true; @@ -215,10 +215,10 @@ public static writer.WriteLine(" }"); writer.Write(" public static void Dispose("); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ value) { - """, isMultiline: true); + """); foreach (FieldDefinition field in type.Fields) { if (field.IsStatic || field.Signature is null) @@ -271,32 +271,32 @@ public static if (isEnum || almostBlittable || isComplexStruct) { - writer.Write($$""" + writer.Write(isMultiline: true, $$""" ? value) { return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.{{(hasReferenceFields ? "TrackerSupport" : "None")}}, in - """, isMultiline: true); + """); ObjRefNameGenerator.WriteIidReferenceExpression(writer, type); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ); } - """, isMultiline: true); + """); } else { // Mapped struct (Duration/KeyTime/etc.): BoxToUnmanaged is still required because the // public projected type still routes through this marshaller (it just lacks per-field // ConvertToUnmanaged/ConvertToManaged because the field layout doesn't match). - writer.Write(""" + writer.Write(isMultiline: true, """ ? value) { return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.None, in - """, isMultiline: true); + """); ObjRefNameGenerator.WriteIidReferenceExpression(writer, type); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ); } - """, isMultiline: true); + """); } // UnboxToManaged: simple for almost-blittable; for complex, unbox to ABI struct then ConvertToManaged. @@ -305,47 +305,47 @@ public static if (isEnum || almostBlittable) { - writer.Write(""" + writer.Write(isMultiline: true, """ ? UnboxToManaged(void* value) { return WindowsRuntimeValueTypeMarshaller.UnboxToManaged< - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ >(value); } - """, isMultiline: true); + """); } else if (isComplexStruct) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ? UnboxToManaged(void* value) { - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); writer.Write("? abi = WindowsRuntimeValueTypeMarshaller.UnboxToManaged<"); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ >(value); return abi.HasValue ? ConvertToManaged(abi.GetValueOrDefault()) : null; } - """, isMultiline: true); + """); } else { // Mapped struct: unbox directly to projected type (no per-field ConvertToManaged needed // because the projected struct's field layout matches the WinMD struct layout). - writer.Write(""" + writer.Write(isMultiline: true, """ ? UnboxToManaged(void* value) { return WindowsRuntimeValueTypeMarshaller.UnboxToManaged< - """, isMultiline: true); + """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ >(value); } - """, isMultiline: true); + """); } writer.WriteLine("}"); @@ -362,7 +362,7 @@ public static string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); // InterfaceEntriesImpl - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" file static class {{nameStripped}}InterfaceEntriesImpl { [FixedAddressValueType] @@ -388,7 +388,7 @@ file static class {{nameStripped}}InterfaceEntriesImpl Entries.IUnknown.Vtable = global::WindowsRuntime.InteropServices.IUnknownImpl.Vtable; } } - """, isMultiline: true); + """); writer.WriteLine(); // is NOT emitted for STRUCTS (the attribute is supplied by cswinrtgen instead). Enums // and other types still emit it from write_abi_enum/etc. @@ -398,7 +398,7 @@ file static class {{nameStripped}}InterfaceEntriesImpl } // ComWrappersMarshallerAttribute (full body) - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" internal sealed unsafe class {{nameStripped}}ComWrappersMarshallerAttribute : WindowsRuntimeComWrappersMarshallerAttribute { public override void* GetOrCreateComInterfaceForObject(object value) @@ -415,7 +415,7 @@ internal sealed unsafe class {{nameStripped}}ComWrappersMarshallerAttribute : Wi public override object CreateObject(void* value, out CreatedWrapperFlags wrapperFlags) { wrapperFlags = CreatedWrapperFlags.NonWrapping; - """, isMultiline: true); + """); if (isComplexStruct) { writer.Write($" return {nameStripped}Marshaller.ConvertToManaged(WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<"); @@ -429,19 +429,19 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper writer.WriteLine($">(value, in {iidRefExpr});"); } - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ } } - """, isMultiline: true); + """); } else { // Fallback: keep the placeholder class so consumer attribute references resolve. - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" internal sealed class {{nameStripped}}ComWrappersMarshallerAttribute : global::System.Attribute { } - """, isMultiline: true); + """); } } } diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 0b2afafa7..dcbbea4f7 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -198,7 +198,7 @@ public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, Proje writer.Write("public static ref readonly Guid "); WriteIidGuidPropertyName(writer, context, type); writer.WriteLine(); - writer.Write(""" + writer.Write(isMultiline: true, """ { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -206,15 +206,15 @@ public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, Proje ReadOnlySpan data = [ - """, isMultiline: true); + """); WriteGuidBytes(writer, type); writer.WriteLine(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ]; return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); } } - """, isMultiline: true); + """); writer.WriteLine(); } @@ -408,7 +408,7 @@ public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, writer.Write("public static ref readonly Guid "); WriteIidReferenceGuidPropertyName(writer, context, type); writer.WriteLine(); - writer.Write(""" + writer.Write(isMultiline: true, """ { [MethodImpl(MethodImplOptions.AggressiveInlining)] get @@ -416,7 +416,7 @@ public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, ReadOnlySpan data = [ - """, isMultiline: true); + """); for (int i = 0; i < 16; i++) { if (i > 0) @@ -427,12 +427,12 @@ public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, writer.Write($"0x{bytes[i].ToString("X", CultureInfo.InvariantCulture)}"); } writer.WriteLine(); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ]; return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); } } - """, isMultiline: true); + """); writer.WriteLine(); } @@ -501,7 +501,7 @@ public static void WriteIidGuidPropertyForClassInterfaces(IndentedTextWriter wri public static void WriteInterfaceIidsBegin(IndentedTextWriter writer) { writer.WriteLine(); - writer.WriteLine($$""" + writer.WriteLine(isMultiline: true, $$""" //------------------------------------------------------------------------------ // // This file was generated by cswinrt.exe version {{MetadataAttributeFactory.GetVersionString()}} @@ -519,7 +519,7 @@ namespace ABI; internal static class InterfaceIIDs { - """, isMultiline: true); + """); } /// diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 769231693..a78901a1f 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -264,10 +264,10 @@ internal static void EmitUnsafeAccessorForIid(IndentedTextWriter writer, Project { string propName = BuildIidPropertyNameForGenericInterface(context, gi); string interopName = InteropTypeNameWriter.EncodeInteropTypeName(gi, TypedefNameType.InteropIID); - writer.Write($$""" + writer.Write(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "get_IID_{{interopName}}")] static extern ref readonly Guid {{propName}}([UnsafeAccessorType("ABI.InterfaceIIDs, WinRT.Interop")] object - """, isMultiline: true); + """); if (isInNullableContext) { writer.Write("?"); @@ -457,7 +457,7 @@ private static void EmitObjRefForInterface(IndentedTextWriter writer, Projection // Lazy CompareExchange pattern. For unsealed-class defaults, also emit 'init;' so the // constructor can assign NativeObjectReference for the exact-type case. - writer.Write($$""" + writer.Write(isMultiline: true, $$""" private WindowsRuntimeObjectReference {{objRefName}} { get @@ -468,9 +468,9 @@ WindowsRuntimeObjectReference MakeObjectReference() _ = global::System.Threading.Interlocked.CompareExchange( location1: ref field, value: NativeObjectReference.As( - """, isMultiline: true); + """); WriteIidExpression(writer, context, ifaceRef); - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ ), comparand: null); @@ -479,7 +479,7 @@ WindowsRuntimeObjectReference MakeObjectReference() return field ?? MakeObjectReference(); } - """, isMultiline: true); + """); if (isDefault) { writer.WriteLine(" init;"); diff --git a/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs b/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs index cd3f46902..623b6a677 100644 --- a/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs +++ b/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs @@ -19,7 +19,7 @@ internal static class WellKnownInterfaceEntriesEmitter /// The writer to emit to. public static void EmitDelegateReferenceWellKnownEntries(IndentedTextWriter writer) { - writer.WriteLine(""" + writer.WriteLine(isMultiline: true, """ Entries.IPropertyValue.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IPropertyValue; Entries.IPropertyValue.Vtable = global::WindowsRuntime.InteropServices.IPropertyValueImpl.OtherTypeVtable; Entries.IStringable.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IStringable; @@ -34,6 +34,6 @@ public static void EmitDelegateReferenceWellKnownEntries(IndentedTextWriter writ Entries.IInspectable.Vtable = global::WindowsRuntime.InteropServices.IInspectableImpl.Vtable; Entries.IUnknown.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IUnknown; Entries.IUnknown.Vtable = global::WindowsRuntime.InteropServices.IUnknownImpl.Vtable; - """, isMultiline: true); + """); } } From 958578eb7b20ac7e014baf2f02c65413f1d5ca2c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 12:43:00 -0700 Subject: [PATCH 005/171] Reshape WriteLineIf overloads to match the canonical Write[Line]/WriteIf pattern The two `WriteLineIf` content overloads still had `bool isMultiline = false` as a trailing parameter with a default value -- a leftover from before the `isMultiline`-first refactor. The other overload families (`Write`/`WriteLine`/`WriteIf`) all use a pair-of-overloads pattern where each content overload has a sibling that takes `isMultiline` immediately before the content (no default). Reshape `WriteLineIf` to match. The `WriteLineIf(bool condition, bool skipIfPresent = false)` newline-only overload remains unchanged (analogous to `WriteLine(bool skipIfPresent = false)`). The two content overloads each gain a sibling: - `WriteLineIf(bool condition, string content)` - `WriteLineIf(bool condition, bool isMultiline, string content)` (new shape) - `WriteLineIf(bool condition, ReadOnlySpan content)` - `WriteLineIf(bool condition, bool isMultiline, ReadOnlySpan content)` (new shape) No callers needed updating: `WriteLineIf` has zero external callers in the writer codebase. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Writers/IndentedTextWriter.cs | 35 ++++++++++++++++--- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index fba42dbda..b7f4754af 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -389,9 +389,23 @@ public void WriteLineIf(bool condition, bool skipIfPresent = false) /// /// When , writes +newline; otherwise this call is a no-op. /// The content to write. + /// + public void WriteLineIf(bool condition, string content) + { + if (condition) + { + WriteLine(isMultiline: false, content.AsSpan()); + } + } + + /// + /// Writes followed by a newline if is . + /// + /// When , writes +newline; otherwise this call is a no-op. /// When , treats as multiline. + /// The content to write. /// - public void WriteLineIf(bool condition, string content, bool isMultiline = false) + public void WriteLineIf(bool condition, bool isMultiline, string content) { if (condition) { @@ -404,14 +418,27 @@ public void WriteLineIf(bool condition, string content, bool isMultiline = false /// /// When , writes +newline; otherwise this call is a no-op. /// The content to write. + /// + public void WriteLineIf(bool condition, ReadOnlySpan content) + { + if (condition) + { + WriteLine(isMultiline: false, content); + } + } + + /// + /// Writes followed by a newline if is . + /// + /// When , writes +newline; otherwise this call is a no-op. /// When , treats as multiline. + /// The content to write. /// - public void WriteLineIf(bool condition, ReadOnlySpan content, bool isMultiline = false) + public void WriteLineIf(bool condition, bool isMultiline, ReadOnlySpan content) { if (condition) { - Write(isMultiline, content); - WriteLine(); + WriteLine(isMultiline, content); } } From 8f2f36e97ddfb18e7a0d2aaf4899c9003f6b24f7 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 12:46:05 -0700 Subject: [PATCH 006/171] Add conditional AppendInterpolatedStringHandler ctors Introduce two constructor overloads for IndentedTextWriter.AppendInterpolatedStringHandler to support compiler-generated conditional interpolated string emission. Both overloads accept literalLength, formattedCount, writer, condition and an out bool shouldAppend; one overload also accepts an isMultiline parameter. When condition is false the handler is disabled (shouldAppend = false), _writer is set to null! and _isMultiline is set to false; when true the writer and multiline flag are initialized. XML docs note these are intended for compiler use and arguments are not validated. --- ...tWriter.AppendInterpolatedStringHandler.cs | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index 863ea023f..d8a413d23 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -54,6 +54,70 @@ public AppendInterpolatedStringHandler( _isMultiline = isMultiline; } + /// Creates a handler used to append an interpolated string into a . + /// The number of constant characters outside of interpolation expressions in the interpolated string. + /// The number of interpolation expressions in the interpolated string. + /// The associated to which to append. + /// When , writes the content, otherwise it does nothing. + /// Whether the handler is enabled. + /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. + public AppendInterpolatedStringHandler( + int literalLength, + int formattedCount, + IndentedTextWriter writer, + bool condition, + out bool shouldAppend) + { + if (condition) + { + _writer = writer; + _isMultiline = false; + + shouldAppend = true; + } + else + { + // We're intentionally suppressing the warning here: the writer shouldn't ever be + // used if the handler is disabled, this just further validates it (it would throw). + _writer = null!; + _isMultiline = false; + + shouldAppend = false; + } + } + + /// Creates a handler used to append an interpolated string into a . + /// The number of constant characters outside of interpolation expressions in the interpolated string. + /// The number of interpolation expressions in the interpolated string. + /// The associated to which to append. + /// When , writes the content, otherwise it does nothing. + /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). + /// Whether the handler is enabled. + /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. + public AppendInterpolatedStringHandler( + int literalLength, + int formattedCount, + IndentedTextWriter writer, + bool condition, + bool isMultiline, + out bool shouldAppend) + { + if (condition) + { + _writer = writer; + _isMultiline = isMultiline; + + shouldAppend = true; + } + else + { + _writer = null!; + _isMultiline = false; + + shouldAppend = false; + } + } + /// Writes the specified string to the handler. /// The string to write. public void AppendLiteral(string value) From bcdcfed5fcf3f43b1d85fa7786df2be02858c011 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 12:47:33 -0700 Subject: [PATCH 007/171] Add XML docs to new WriteIf/WriteLineIf interpolated handler overloads Combines the conditional-style docs from the existing string/span `WriteIf` and `WriteLineIf` overloads with the interpolated-handler-style docs from the existing `Write` and `WriteLine` handler overloads, matching the documentation pattern used everywhere else in the file. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Writers/IndentedTextWriter.cs | 49 +++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index b7f4754af..d540ec97f 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -221,6 +221,29 @@ public void Write(bool isMultiline, ReadOnlySpan content) } } + /// + /// Writes an interpolated expression to the underlying buffer if is ; otherwise does nothing. + /// + /// When , writes ; otherwise this call is a no-op. + /// The interpolated content to write. + /// + public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref AppendInterpolatedStringHandler handler) + { + _ = this; + } + + /// + /// Writes an interpolated expression to the underlying buffer if is ; otherwise does nothing. + /// + /// When , writes ; otherwise this call is a no-op. + /// When , treats as multiline. + /// The interpolated content to write. + /// + public void WriteIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) + { + _ = this; + } + /// /// Writes to the underlying buffer if is ; otherwise does nothing. /// @@ -384,6 +407,32 @@ public void WriteLineIf(bool condition, bool skipIfPresent = false) } } + /// + /// Writes an interpolated expression to the underlying buffer followed by a newline if is ; otherwise does nothing. + /// + /// When , writes +newline; otherwise this call is a no-op. + /// The interpolated content to write. + /// + public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref AppendInterpolatedStringHandler handler) + { + _ = this; + } + + /// + /// Writes an interpolated expression to the underlying buffer followed by a newline if is ; otherwise does nothing. + /// + /// When , writes +newline; otherwise this call is a no-op. + /// When , treats as multiline. + /// The interpolated content to write. + /// + public void WriteLineIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) + { + if (condition) + { + WriteLine(); + } + } + /// /// Writes followed by a newline if is . /// From a4a3e9d0d5fb3995052566499a127f10ce587632 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 13:02:16 -0700 Subject: [PATCH 008/171] Convert simple if-then-write blocks to WriteIf/WriteLineIf Mechanical conversion across the writer codebase: any single-statement `if (cond) { writer.Write[Line](content); }` block where the body is a plain (non-interpolated) string or span call is rewritten to `writer.Write[Line]If(cond, content);`. 68 conversions across 23 files. The conversion intentionally SKIPS interpolated-string calls (`writer.Write($"...")`). The new `WriteIf`/`WriteLineIf` interpolated handler overloads have an unintentional parameter-name mismatch with the existing `AppendInterpolatedStringHandler` constructors: the compiler binds `condition` positionally to the handler's existing `(int, int, IndentedTextWriter, bool isMultiline)` constructor, so `writer.WriteLineIf(false, $"foo")` would silently always write AND treat the content as multiline. Once the handler gets a dedicated `(..., bool condition)` constructor that returns `out bool wantsToContinue` this filter can be relaxed. Conditions skipped by the converter: - if-statement is part of an `else`/`else if` chain (preceded by `else` on the prior non-blank/non-comment line, OR followed by `else` on the next non-blank/non-comment line after the close brace -- the previous filter only checked the immediately-following line and missed cases separated by a blank line + comment). - body uses an interpolated string literal or an `isMultiline:` named argument (which would route to the interpolated handler overload). - body has more than one statement, or body's call doesn't end with `);`. Validation: - Output is byte-identical to the pre-conversion branch baseline (1553/1553). - Real CI-style compile of WinRT.Sdk.Projection + WinRT.Sdk.Xaml.Projection passes with 0 compile errors. - Syntax validation across all 8 regression scenarios passes with 0 errors. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 25 +++-------- .../IndentedTextWriterExtensions.cs | 5 +-- .../Factories/AbiDelegateFactory.cs | 15 ++----- .../Factories/AbiInterfaceFactory.cs | 10 +---- .../Factories/AbiInterfaceIDicFactory.cs | 10 +---- .../AbiMethodBodyFactory.MethodsClass.cs | 5 +-- .../AbiMethodBodyFactory.RcwCaller.cs | 10 +---- .../Factories/ClassFactory.cs | 45 ++++--------------- .../ClassMembersFactory.WriteClassMembers.cs | 5 +-- ...assMembersFactory.WriteInterfaceMembers.cs | 30 +++---------- .../Factories/ClassMembersFactory.cs | 5 +-- .../Factories/ComponentFactory.cs | 5 +-- .../ConstructorFactory.AttributedTypes.cs | 10 +---- .../ConstructorFactory.Composable.cs | 35 +++------------ .../ConstructorFactory.FactoryCallbacks.cs | 10 +---- .../Factories/CustomAttributeFactory.cs | 5 +-- .../Factories/InterfaceFactory.cs | 20 ++------- .../Factories/MethodFactory.cs | 10 +---- .../Factories/StructEnumMarshallerFactory.cs | 10 +---- .../Helpers/IdentifierEscaping.cs | 7 +-- .../Helpers/IidExpressionGenerator.cs | 25 +++-------- .../Helpers/ObjRefNameGenerator.cs | 15 ++----- .../Helpers/TypedefNameWriter.cs | 25 +++-------- 23 files changed, 69 insertions(+), 273 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 65be7d75a..9c9c7ad00 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -110,10 +110,7 @@ public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext co writer.WriteLine(); - if (isFlags) - { - writer.WriteLine("[Flags]"); - } + writer.WriteLineIf(isFlags, "[Flags]"); MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(writer, context, type); @@ -225,10 +222,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(writer, context, type); writer.Write("public"); - if (hasAddition) - { - writer.Write(" partial"); - } + writer.WriteIf(hasAddition, " partial"); writer.WriteLine($" struct {projectionName} : IEquatable<{projectionName}>"); using (writer.WriteBlock()) @@ -236,10 +230,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext writer.Write($"public {projectionName}("); for (int i = 0; i < fields.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); writer.Write($"{fields[i].TypeStr} "); IdentifierEscaping.WriteEscapedIdentifier(writer, fields[i].ParamName); @@ -290,10 +281,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext { for (int i = 0; i < fields.Count; i++) { - if (i > 0) - { - writer.Write(" && "); - } + writer.WriteIf(i > 0, " && "); writer.Write($"x.{fields[i].Name} == y.{fields[i].Name}"); } @@ -313,10 +301,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext { for (int i = 0; i < fields.Count; i++) { - if (i > 0) - { - writer.Write(" ^ "); - } + writer.WriteIf(i > 0, " ^ "); writer.Write($"{fields[i].Name}.GetHashCode()"); } diff --git a/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs b/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs index 6461b5f91..9742e3ac4 100644 --- a/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs @@ -30,10 +30,7 @@ public void WriteSeparated(IEnumerable items, string separator, Action 0) - { - writer.Write(", "); - } + writer.WriteIf(sig.Parameters.Count > 0, ", "); MethodFactory.WriteParameterList(writer, context, sig); writer.Write(")"); @@ -309,10 +306,7 @@ public EventState(void* thisPtr, int index) """); for (int i = 0; i < sig.Parameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); ParameterCategory pc = ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]); @@ -331,10 +325,7 @@ public EventState(void* thisPtr, int index) writer.Write(") => TargetDelegate.Invoke("); for (int i = 0; i < sig.Parameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); ParameterCategory pc = ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]); diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 776ea6a29..b47ac0ac5 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -64,10 +64,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj // void* thisPtr, then each param's ABI type, then return type pointer writer.Write("void*"); - if (includeParamNames) - { - writer.Write(" thisPtr"); - } + writer.WriteIf(includeParamNames, " thisPtr"); for (int i = 0; i < sig.Parameters.Count; i++) { @@ -142,10 +139,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj { AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(p.Type)); - if (cat is ParameterCategory.Out or ParameterCategory.Ref) - { - writer.Write("*"); - } + writer.WriteIf(cat is ParameterCategory.Out or ParameterCategory.Ref, "*"); if (includeParamNames) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index e74f73af1..e9a169dac 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -317,10 +317,7 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented writer.Write($") => (({ccwIfaceName})(WindowsRuntimeObject)this).{mname}("); for (int i = 0; i < sig.Parameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); ClassMembersFactory.WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); } @@ -466,10 +463,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite var _obj = ((WindowsRuntimeObject)this).GetObjectReferenceForInterface(typeof({{ccwIfaceName}}).TypeHandle); """); - if (sig.ReturnType is not null) - { - writer.Write("return "); - } + writer.WriteIf(sig.ReturnType is not null, "return "); writer.Write($"{abiClass}.{mname}(_obj"); for (int i = 0; i < sig.Parameters.Count; i++) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 3cc82e069..ffb007419 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -65,10 +65,7 @@ public static unsafe MethodFactory.WriteProjectionReturnType(writer, context, sig); writer.Write($" {mname}(WindowsRuntimeObjectReference thisReference"); - if (sig.Parameters.Count > 0) - { - writer.Write(", "); - } + writer.WriteIf(sig.Parameters.Count > 0, ", "); MethodFactory.WriteParameterList(writer, context, sig); writer.Write(")"); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 1499d2ecc..d2c85913f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -774,10 +774,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - if (!first) - { - writer.Write(", "); - } + writer.WriteIf(!first, ", "); first = false; writer.Write($"_{localName} = "); @@ -1519,10 +1516,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] static extern void Dispose_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{disposeDataParamType}} """); - if (!disposeDataParamType.EndsWith("data", StringComparison.Ordinal)) - { - writer.Write(" data"); - } + writer.WriteIf(!disposeDataParamType.EndsWith("data", StringComparison.Ordinal), " data"); writer.WriteLine(isMultiline: true, $$""" ); diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 78abee3fe..5b1a6340e 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -47,10 +47,7 @@ public static void WriteClassModifiers(IndentedTextWriter writer, TypeDefinition return; } - if (type.IsSealed) - { - writer.Write("sealed "); - } + writer.WriteIf(type.IsSealed, "sealed "); } /// @@ -362,10 +359,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection string mname = method.Name?.Value ?? string.Empty; writer.WriteLine(); - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write("public static "); MethodFactory.WriteProjectionReturnType(writer, context, sig); @@ -395,10 +389,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection string evtName = evt.Name?.Value ?? string.Empty; writer.WriteLine(); - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write("public static event "); TypedefNameWriter.WriteEventType(writer, context, evt); @@ -476,10 +467,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection setterPlat = string.Empty; } - if (!string.IsNullOrEmpty(propertyPlat)) - { - writer.Write(propertyPlat); - } + writer.WriteIf(!string.IsNullOrEmpty(propertyPlat), propertyPlat); writer.Write($"public static {s.PropTypeText} {kv.Key}"); // Getter-only -> expression body; otherwise -> accessor block (matches truth). @@ -504,10 +492,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection { if (s.HasGetter) { - if (!string.IsNullOrEmpty(getterPlat)) - { - writer.Write(getterPlat); - } + writer.WriteIf(!string.IsNullOrEmpty(getterPlat), getterPlat); if (context.Settings.ReferenceProjection) { @@ -521,10 +506,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection if (s.HasSetter) { - if (!string.IsNullOrEmpty(setterPlat)) - { - writer.Write(setterPlat); - } + writer.WriteIf(!string.IsNullOrEmpty(setterPlat), setterPlat); if (context.Settings.ReferenceProjection) { @@ -754,10 +736,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont continue; } - if (!firstClause) - { - writer.Write(" || "); - } + writer.WriteIf(!firstClause, " || "); firstClause = false; ObjRefNameGenerator.WriteIidExpression(writer, context, implRef); @@ -771,19 +750,13 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont if (hasBaseClass) { - if (!firstClause) - { - writer.Write(" || "); - } + writer.WriteIf(!firstClause, " || "); writer.Write("base.IsOverridableInterface(in iid)"); firstClause = false; } - if (firstClause) - { - writer.Write("false"); - } + writer.WriteIf(firstClause, "false"); writer.WriteLine(";"); } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index d61214be0..79543f3de 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -73,10 +73,7 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo setterPlat = string.Empty; } - if (!string.IsNullOrEmpty(propertyPlat)) - { - writer.Write(propertyPlat); - } + writer.WriteIf(!string.IsNullOrEmpty(propertyPlat), propertyPlat); writer.Write($"{s.Access}{s.MethodSpec}{s.PropTypeText} {kvp.Key}"); // For getter-only properties, emit expression body: 'public T Prop => Expr;' diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index b3abbfefa..5fb953312 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -129,10 +129,7 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr writer.WriteLine(); writer.Write("internal "); - if (hasBaseType) - { - writer.Write("new "); - } + writer.WriteIf(hasBaseType, "new "); writer.WriteLine(isMultiline: true, $$""" WindowsRuntimeObjectReferenceValue GetDefaultInterface() @@ -330,10 +327,7 @@ static extern writer.WriteLine(");"); // string to each public method emission. In ref mode this produces e.g. // [global::System.Runtime.Versioning.SupportedOSPlatform("Windows10.0.16299.0")]. - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write($"{access}{methodSpecForThis}"); MethodFactory.WriteProjectionReturnType(writer, context, sig); @@ -360,10 +354,7 @@ static extern { writer.WriteLine(); - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write($"{access}{methodSpecForThis}"); MethodFactory.WriteProjectionReturnType(writer, context, sig); @@ -392,10 +383,7 @@ static extern if (isOverridable) { // impl as well (since it shares the same originating interface). - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); MethodFactory.WriteProjectionReturnType(writer, context, sig); writer.Write(" "); @@ -405,10 +393,7 @@ static extern writer.Write($") => {name}("); for (int i = 0; i < sig.Parameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); } @@ -583,10 +568,7 @@ static extern writer.WriteLine(); // string to each event emission. In ref mode this produces e.g. // [global::System.Runtime.Versioning.SupportedOSPlatform("Windows10.0.16299.0")]. - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write($"{access}{methodSpec}event "); TypedefNameWriter.WriteEventType(writer, context, evt, currentInstance); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 31b842054..3e8d8df3a 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -157,10 +157,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro writer.Write($"global::{ns}.{IdentifierEscaping.StripBackticks(name)}<"); for (int i = 0; i < gi.TypeArguments.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); TypedefNameWriter.WriteTypeName(writer, context, TypeSemanticsFactory.Get(gi.TypeArguments[i]), TypedefNameType.Projected, true); } diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 88a686adf..7923a9066 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -300,10 +300,7 @@ private static void WriteFactoryMethodParameters(IndentedTextWriter writer, Proj for (int i = 0; i < sig.ParameterTypes.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); ParameterDefinition? p = method.Parameters.Count > i ? method.Parameters[i].Definition : null; string paramName = p?.Name?.Value ?? $"arg{i}"; diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 8f75453bf..1762df991 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -120,10 +120,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio // Emit the public constructor. writer.WriteLine(); - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write($"public unsafe {typeName}("); MethodFactory.WriteParameterList(writer, context, sig); @@ -140,10 +137,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio writer.Write($"{callbackName}.Instance, {defaultIfaceIid}, {marshalingType}, WindowsRuntimeActivationArgsReference.CreateUnsafe(new {argsName}("); for (int i = 0; i < sig.Parameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); string raw = sig.Parameters[i].Parameter.Name ?? "param"; writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 8412d1d28..32be0f500 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -68,10 +68,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec writer.WriteLine(); - if (!string.IsNullOrEmpty(platformAttribute)) - { - writer.Write(platformAttribute); - } + writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); writer.Write(visibility); @@ -87,10 +84,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec writer.Write($"{typeName}("); for (int i = 0; i < userParamCount; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); } @@ -110,10 +104,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec writer.Write($"{callbackName}.Instance, {defaultIfaceIid}, {marshalingType}, WindowsRuntimeActivationArgsReference.CreateUnsafe(new {argsName}("); for (int i = 0; i < userParamCount; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); string raw = sig.Parameters[i].Parameter.Name ?? "param"; writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); @@ -171,10 +162,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec """); using (writer.WriteBlock()) { - if (!string.IsNullOrEmpty(gcPressureBody)) - { - writer.WriteLine(gcPressureBody); - } + writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); } writer.WriteLine(); @@ -184,10 +172,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec """); using (writer.WriteBlock()) { - if (!string.IsNullOrEmpty(gcPressureBody)) - { - writer.WriteLine(gcPressureBody); - } + writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); } writer.WriteLine(); @@ -197,10 +182,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec """); using (writer.WriteBlock()) { - if (!string.IsNullOrEmpty(gcPressureBody)) - { - writer.WriteLine(gcPressureBody); - } + writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); } writer.WriteLine(); @@ -210,10 +192,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec """); using (writer.WriteBlock()) { - if (!string.IsNullOrEmpty(gcPressureBody)) - { - writer.WriteLine(gcPressureBody); - } + writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); } } } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 145335aca..abdd093ec 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -33,10 +33,7 @@ private static void EmitFactoryArgsStruct(IndentedTextWriter writer, ProjectionE writer.Write($"private readonly ref struct {argsName}("); for (int i = 0; i < count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); } @@ -374,10 +371,7 @@ public override unsafe void Invoke( string raw = p.Parameter.Name ?? "param"; string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; - if (!firstPin) - { - writer.Write(", "); - } + writer.WriteIf(!firstPin, ", "); firstPin = false; writer.Write($"_{raw} = "); diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index 49270e729..865a13782 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -424,10 +424,7 @@ public static void WriteCustomAttributes(IndentedTextWriter writer, ProjectionEm writer.Write("("); for (int i = 0; i < kv.Value.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); writer.Write(kv.Value[i]); } diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index dd4b9f19d..9afbc3440 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -179,10 +179,7 @@ public static void WriteInterfaceTypeName(IndentedTextWriter writer, ProjectionE writer.Write($"{IdentifierEscaping.StripBackticks(name)}<"); for (int i = 0; i < gi.TypeArguments.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); // Pass forceWriteNamespace=false so type args also respect the current namespace. TypedefNameWriter.WriteTypeName(writer, context, TypeSemanticsFactory.Get(gi.TypeArguments[i]), TypedefNameType.Projected, false); @@ -252,15 +249,9 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro string propType = WritePropType(context, prop); writer.Write($"{newKeyword}{propType} {prop.Name?.Value ?? string.Empty} {{"); - if (getter is not null || setter is not null) - { - writer.Write(" get;"); - } + writer.WriteIf(getter is not null || setter is not null, " get;"); - if (setter is not null) - { - writer.Write(" set;"); - } + writer.WriteIf(setter is not null, " set;"); writer.WriteLine(" }"); } @@ -427,10 +418,7 @@ private static void WriteMethodCustomAttributes(IndentedTextWriter writer, Metho writer.Write("("); for (int i = 0; i < attr.Signature.FixedArguments.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); object? val = attr.Signature.FixedArguments[i].Element; diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index 216a213a1..d9432334c 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -131,10 +131,7 @@ public static void WriteParameterName(IndentedTextWriter writer, ParameterInfo p { string name = p.Parameter.Name ?? "param"; - if (CSharpKeywords.IsKeyword(name)) - { - writer.Write("@"); - } + writer.WriteIf(CSharpKeywords.IsKeyword(name), "@"); writer.Write(name); } @@ -181,10 +178,7 @@ public static void WriteParameterList(IndentedTextWriter writer, ProjectionEmitC { for (int i = 0; i < sig.Parameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); WriteProjectionParameter(writer, context, sig.Parameters[i]); } diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 80f8088c8..170204963 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -93,10 +93,7 @@ public static unsafe class {{nameStripped}}Marshaller string fname = field.Name?.Value ?? ""; TypeSignature ft = field.Signature.FieldType; - if (!first) - { - writer.WriteLine(","); - } + writer.WriteLineIf(!first, ","); first = false; writer.Write($" {fname} = "); @@ -165,10 +162,7 @@ public static string fname = field.Name?.Value ?? ""; TypeSignature ft = field.Signature.FieldType; - if (!first) - { - writer.WriteLine(","); - } + writer.WriteLineIf(!first, ","); first = false; writer.Write(" "); diff --git a/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs b/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs index a1798b215..b4b0d466a 100644 --- a/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs +++ b/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs @@ -30,10 +30,7 @@ public static string StripBackticks(string typeName) /// The identifier to write. public static void WriteEscapedIdentifier(IndentedTextWriter writer, string identifier) { - if (CSharpKeywords.IsKeyword(identifier)) - { - writer.Write("@"); - } + writer.WriteIf(CSharpKeywords.IsKeyword(identifier), "@"); writer.Write(identifier); } @@ -61,4 +58,4 @@ public static string ToCamelCase(string name) return name; } -} \ No newline at end of file +} diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index dcbbea4f7..32a0fea92 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -164,10 +164,7 @@ public static void WriteGuidBytes(IndentedTextWriter writer, TypeDefinition type } private static void WriteByte(IndentedTextWriter writer, uint b, bool first) { - if (!first) - { - writer.Write(", "); - } + writer.WriteIf(!first, ", "); writer.Write($"0x{(b & 0xFF).ToString("X", CultureInfo.InvariantCulture)}"); } @@ -261,10 +258,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC writer.Write("};"); for (int i = 0; i < gi.GenericArgs.Count; i++) { - if (i > 0) - { - writer.Write(";"); - } + writer.WriteIf(i > 0, ";"); WriteGuidSignature(writer, context, gi.GenericArgs[i]); } @@ -291,10 +285,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC writer.Write("};"); for (int i = 0; i < gir.GenericArgs.Count; i++) { - if (i > 0) - { - writer.Write(";"); - } + writer.WriteIf(i > 0, ";"); WriteGuidSignature(writer, context, gir.GenericArgs[i]); } @@ -352,10 +343,7 @@ private static void WriteGuidSignatureForType(IndentedTextWriter writer, Project continue; } - if (!first) - { - writer.Write(";"); - } + writer.WriteIf(!first, ";"); first = false; WriteGuidSignature(writer, context, TypeSemanticsFactory.Get(field.Signature.FieldType)); @@ -419,10 +407,7 @@ public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, """); for (int i = 0; i < 16; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); writer.Write($"0x{bytes[i].ToString("X", CultureInfo.InvariantCulture)}"); } diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index a78901a1f..3fb6c4b67 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -134,10 +134,7 @@ private static void WriteFullyQualifiedInterfaceName(IndentedTextWriter writer, writer.Write($"{IdentifierEscaping.StripBackticks(name)}<"); for (int i = 0; i < gi.TypeArguments.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); // forceWriteNamespace=true so generic args also get global:: prefix. TypedefNameWriter.WriteTypeName(writer, context, TypeSemanticsFactory.Get(gi.TypeArguments[i]), TypedefNameType.Projected, true); @@ -268,10 +265,7 @@ internal static void EmitUnsafeAccessorForIid(IndentedTextWriter writer, Project [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "get_IID_{{interopName}}")] static extern ref readonly Guid {{propName}}([UnsafeAccessorType("ABI.InterfaceIIDs, WinRT.Interop")] object """); - if (isInNullableContext) - { - writer.Write("?"); - } + writer.WriteIf(isInNullableContext, "?"); writer.WriteLine(" _);"); } @@ -480,10 +474,7 @@ WindowsRuntimeObjectReference MakeObjectReference() return field ?? MakeObjectReference(); } """); - if (isDefault) - { - writer.WriteLine(" init;"); - } + writer.WriteLineIf(isDefault, " init;"); writer.WriteLine("}"); } diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 512880468..1797eac25 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -173,10 +173,7 @@ public static void WriteTypeParams(IndentedTextWriter writer, TypeDefinition typ writer.Write("<"); for (int i = 0; i < type.GenericParameters.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); string? gpName = type.GenericParameters[i].Name?.Value; writer.Write(gpName ?? $"T{i}"); @@ -217,10 +214,7 @@ public static void WriteTypeName(IndentedTextWriter writer, ProjectionEmitContex writer.Write("<"); for (int i = 0; i < gi.GenericArgs.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); // Generic args ALWAYS use Projected, regardless of parent's nameType. WriteTypeName(writer, context, gi.GenericArgs[i], TypedefNameType.Projected, forceWriteNamespace); @@ -246,10 +240,7 @@ public static void WriteTypeName(IndentedTextWriter writer, ProjectionEmitContex { writer.Write(GlobalPrefix); - if (nameType is TypedefNameType.ABI or TypedefNameType.StaticAbiClass or TypedefNameType.EventSource) - { - writer.Write("ABI."); - } + writer.WriteIf(nameType is TypedefNameType.ABI or TypedefNameType.StaticAbiClass or TypedefNameType.EventSource, "ABI."); writer.Write($"{ns}."); } @@ -268,10 +259,7 @@ public static void WriteTypeName(IndentedTextWriter writer, ProjectionEmitContex writer.Write("<"); for (int i = 0; i < gir.GenericArgs.Count; i++) { - if (i > 0) - { - writer.Write(", "); - } + writer.WriteIf(i > 0, ", "); WriteTypeName(writer, context, gir.GenericArgs[i], TypedefNameType.Projected, forceWriteNamespace); } @@ -300,10 +288,7 @@ public static void WriteTypeName(IndentedTextWriter writer, ProjectionEmitContex { writer.Write(GlobalPrefix); - if (nameType is TypedefNameType.ABI or TypedefNameType.StaticAbiClass or TypedefNameType.EventSource) - { - writer.Write("ABI."); - } + writer.WriteIf(nameType is TypedefNameType.ABI or TypedefNameType.StaticAbiClass or TypedefNameType.EventSource, "ABI."); writer.Write($"{ns}."); } From 25e76b07b8fffe673f7740b2a5ddefa3e7a13ae4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 15:35:03 -0700 Subject: [PATCH 009/171] Add TryAppendInterpolatedStringHandler partial type Introduce a separate interpolated-string handler type for conditional write paths (WriteIf/WriteLineIf). It mirrors the shape and members of AppendInterpolatedStringHandler but only exposes the constructors that take a leading 'condition' argument and produce 'out bool shouldAppend', which is the contract the language compiler requires to short-circuit literal/interpolation evaluation when the condition is false. Splitting this into its own handler type avoids the constructor-overload collision with the unconditional Write/WriteLine overloads: per the interpolated-string-handler resolution rules, the compiler always prefers a constructor with a trailing 'out bool shouldAppend' parameter when one exists with a matching shape, which would otherwise silently bind unconditional 'Write(bool isMultiline, ...)' calls to the conditional constructor and lose the isMultiline value. This commit only adds the new type. Wiring WriteIf/WriteLineIf to it (and removing the now-redundant conditional constructors from AppendInterpolatedStringHandler) follows in a separate commit. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- ...iter.TryAppendInterpolatedStringHandler.cs | 171 ++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs new file mode 100644 index 000000000..b3041d2ce --- /dev/null +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs @@ -0,0 +1,171 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System; +using System.ComponentModel; +using System.Runtime.CompilerServices; +using System.Text; + +namespace WindowsRuntime.ProjectionWriter.Writers; + +/// +internal partial class IndentedTextWriter +{ + /// + /// Provides a handler used by the language compiler to conditionally append interpolated strings into instances. + /// + /// + /// This handler differs from in that it accepts a leading condition argument and short-circuits + /// the entire interpolation when that condition is : no AppendLiteral or AppendFormatted call is emitted by + /// the compiler, so neither the literal segments nor the interpolation expressions are evaluated. + /// + [EditorBrowsable(EditorBrowsableState.Never)] + [InterpolatedStringHandler] + public readonly ref struct TryAppendInterpolatedStringHandler + { + /// The associated to which to append. + private readonly IndentedTextWriter _writer; + + /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). + private readonly bool _isMultiline; + + /// Creates a handler used to conditionally append an interpolated string into a . + /// The number of constant characters outside of interpolation expressions in the interpolated string. + /// The number of interpolation expressions in the interpolated string. + /// The associated to which to append. + /// When , writes the content, otherwise it does nothing. + /// Whether the handler is enabled. + /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. + public TryAppendInterpolatedStringHandler( + int literalLength, + int formattedCount, + IndentedTextWriter writer, + bool condition, + out bool shouldAppend) + { + if (condition) + { + _writer = writer; + _isMultiline = false; + + shouldAppend = true; + } + else + { + // We're intentionally suppressing the warning here: the writer shouldn't ever be + // used if the handler is disabled, this just further validates it (it would throw). + _writer = null!; + _isMultiline = false; + + shouldAppend = false; + } + } + + /// Creates a handler used to conditionally append an interpolated string into a . + /// The number of constant characters outside of interpolation expressions in the interpolated string. + /// The number of interpolation expressions in the interpolated string. + /// The associated to which to append. + /// When , writes the content, otherwise it does nothing. + /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). + /// Whether the handler is enabled. + /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. + public TryAppendInterpolatedStringHandler( + int literalLength, + int formattedCount, + IndentedTextWriter writer, + bool condition, + bool isMultiline, + out bool shouldAppend) + { + if (condition) + { + _writer = writer; + _isMultiline = isMultiline; + + shouldAppend = true; + } + else + { + _writer = null!; + _isMultiline = false; + + shouldAppend = false; + } + } + + /// Writes the specified string to the handler. + /// The string to write. + public void AppendLiteral(string value) + { + _writer.Write(_isMultiline, value); + } + + /// Writes the specified value to the handler. + /// The value to write. + /// The type of the value to write. + public void AppendFormatted(T value) + { + if (value is null) + { + return; + } + + // If the value is a 'string', write it while preserving the multiline semantics. + // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. + if (value is string text) + { + _writer.Write(_isMultiline, text); + } + else + { + _ = _writer._buffer.Append($"{value}"); + } + } + + /// Writes the specified value to the handler. + /// The value to write. + /// The format string. + /// The type of the value to write. + public void AppendFormatted(T value, string? format) + { + if (value is null) + { + return; + } + + // If the value is a 'string', write it while preserving the multiline semantics. + // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. + if (value is string text) + { + _writer.Write(_isMultiline, text); + } + else + { + StringBuilder.AppendInterpolatedStringHandler handler = new(0, 1, _writer._buffer); + + handler.AppendFormatted(value, format); + + _ = _writer._buffer.Append(ref handler); + } + } + + /// Writes the specified character span to the handler. + /// The span to write. + public void AppendFormatted(scoped ReadOnlySpan value) + { + _writer.Write(_isMultiline, value); + } + + /// Writes the specified value to the handler. + /// The value to write. + public void AppendFormatted(string? value) + { + if (value is null) + { + return; + } + + _writer.Write(_isMultiline, value); + } + } +} From fe4fd5accf3ea24cefdb57a266e8cee5e0565a2c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 15:55:16 -0700 Subject: [PATCH 010/171] Switch WriteIf/WriteLineIf to TryAppendInterpolatedStringHandler Update the four interpolated-handler overloads on WriteIf/WriteLineIf to take a 'ref TryAppendInterpolatedStringHandler' parameter instead of 'ref AppendInterpolatedStringHandler', and remove the now-unused conditional constructors from AppendInterpolatedStringHandler. This fixes a latent bug introduced when the conditional constructors were originally added to AppendInterpolatedStringHandler. Per the language rules for interpolated-string-handler resolution, the compiler always prefers a constructor with a trailing 'out bool shouldAppend' parameter when one exists with a matching shape. Both WriteIf(bool condition, ...) and Write(bool isMultiline, ...) produce the same expected handler-constructor signature (int, int, IndentedTextWriter, bool) from their respective [InterpolatedStringHandlerArgument] attributes, so the addition of the 5/6-arg conditional constructors silently caused all Write(isMultiline: true, $$..."""...""") calls to bind to the conditional constructor, where the bool parameter was treated as a condition flag and _isMultiline was unconditionally forced to false. As a result, the AppendLiteral path stopped splitting multi-line raw-string content per line and lost the per-line indent contribution, producing visibly broken indentation inside generated projection sources wherever an interpolated multi-line raw string was written. Splitting the conditional flavor into its own handler type breaks the constructor-shape collision: WriteIf/WriteLineIf still get the short-circuit behavior they need, while Write/WriteLine bind to the AppendInterpolatedStringHandler 4-arg (int, int, writer, bool) constructor as intended. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- ...tWriter.AppendInterpolatedStringHandler.cs | 64 ------------------- .../Writers/IndentedTextWriter.cs | 8 +-- 2 files changed, 4 insertions(+), 68 deletions(-) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index d8a413d23..863ea023f 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -54,70 +54,6 @@ public AppendInterpolatedStringHandler( _isMultiline = isMultiline; } - /// Creates a handler used to append an interpolated string into a . - /// The number of constant characters outside of interpolation expressions in the interpolated string. - /// The number of interpolation expressions in the interpolated string. - /// The associated to which to append. - /// When , writes the content, otherwise it does nothing. - /// Whether the handler is enabled. - /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. - public AppendInterpolatedStringHandler( - int literalLength, - int formattedCount, - IndentedTextWriter writer, - bool condition, - out bool shouldAppend) - { - if (condition) - { - _writer = writer; - _isMultiline = false; - - shouldAppend = true; - } - else - { - // We're intentionally suppressing the warning here: the writer shouldn't ever be - // used if the handler is disabled, this just further validates it (it would throw). - _writer = null!; - _isMultiline = false; - - shouldAppend = false; - } - } - - /// Creates a handler used to append an interpolated string into a . - /// The number of constant characters outside of interpolation expressions in the interpolated string. - /// The number of interpolation expressions in the interpolated string. - /// The associated to which to append. - /// When , writes the content, otherwise it does nothing. - /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). - /// Whether the handler is enabled. - /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. - public AppendInterpolatedStringHandler( - int literalLength, - int formattedCount, - IndentedTextWriter writer, - bool condition, - bool isMultiline, - out bool shouldAppend) - { - if (condition) - { - _writer = writer; - _isMultiline = isMultiline; - - shouldAppend = true; - } - else - { - _writer = null!; - _isMultiline = false; - - shouldAppend = false; - } - } - /// Writes the specified string to the handler. /// The string to write. public void AppendLiteral(string value) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index d540ec97f..a0299eff5 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -227,7 +227,7 @@ public void Write(bool isMultiline, ReadOnlySpan content) /// When , writes ; otherwise this call is a no-op. /// The interpolated content to write. /// - public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref AppendInterpolatedStringHandler handler) + public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref TryAppendInterpolatedStringHandler handler) { _ = this; } @@ -239,7 +239,7 @@ public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameo /// When , treats as multiline. /// The interpolated content to write. /// - public void WriteIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) + public void WriteIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref TryAppendInterpolatedStringHandler handler) { _ = this; } @@ -413,7 +413,7 @@ public void WriteLineIf(bool condition, bool skipIfPresent = false) /// When , writes +newline; otherwise this call is a no-op. /// The interpolated content to write. /// - public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref AppendInterpolatedStringHandler handler) + public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref TryAppendInterpolatedStringHandler handler) { _ = this; } @@ -425,7 +425,7 @@ public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", n /// When , treats as multiline. /// The interpolated content to write. /// - public void WriteLineIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref AppendInterpolatedStringHandler handler) + public void WriteLineIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref TryAppendInterpolatedStringHandler handler) { if (condition) { From 6c794ba993e122a826f4a399f35982daa8728f5f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:00:18 -0700 Subject: [PATCH 011/171] Add IIndentedTextWriterCallback factory-callback infrastructure Introduce a small "callback" mechanism that lets factories return a readonly value-type closure which can be embedded as an interpolation hole inside an interpolated raw string passed to Write/WriteLine. The callback's Write method is invoked at interpolation time and emits its content directly into the writer at the writer's current position and indentation level, with no allocation and no intermediate string. This lets emission code that previously had to break a single multiline fragment into three separate calls (a leading writer.Write of the prefix, a helper that emits a piece of derived content, and a trailing writer.WriteLine of the suffix) collapse back into a single, readable interpolated raw string with the helper inlined as an interpolation hole, while preserving the same output and the same zero-allocation characteristics. The new pieces are: - IIndentedTextWriterCallback: marker interface implemented by the callback closures. - WriteIidGuidReferenceCallback: the first concrete callback, emitted by the new AbiTypeHelpers.WriteIidGuidReference(context, type) overload to inline the IID GUID literal expression. - AppendFormatted dispatch on both interpolated-string handlers (AppendInterpolatedStringHandler and TryAppendInterpolatedStringHandler): when T is a value type that implements IIndentedTextWriterCallback, the handler invokes the callback's Write method directly instead of falling through to the string/StringBuilder path. Use the new pattern in AbiInterfaceFactory in the two places that previously emitted the IID via a three-call sequence (the static IID property body and the inline-IID argument in the marshaller emission). Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceFactory.cs | 17 ++++++------- .../WriteIidGuidReferenceCallback.cs | 19 ++++++++++++++ .../Helpers/AbiTypeHelpers.cs | 16 ++++++++++++ .../Writers/IIndentedTextWriterCallback.cs | 25 +++++++++++++++++++ ...tWriter.AppendInterpolatedStringHandler.cs | 11 ++++++++ ...iter.TryAppendInterpolatedStringHandler.cs | 10 ++++++++ 6 files changed, 88 insertions(+), 10 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidReferenceCallback.cs create mode 100644 src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index b47ac0ac5..b50a87ede 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -263,17 +264,13 @@ public static void WriteInterfaceImpl(IndentedTextWriter writer, ProjectionEmitC string vm = AbiTypeHelpers.GetVirtualMethodName(type, method); writer.WriteLine($" Vftbl.{vm} = &Do_Abi_{vm};"); } - writer.Write(isMultiline: true, """ + writer.Write(isMultiline: true, $$""" } public static ref readonly Guid IID { [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => ref - """); - AbiTypeHelpers.WriteIidGuidReference(writer, context, type); - writer.WriteLine(isMultiline: true, """ - ; + get => ref {{AbiTypeHelpers.WriteIidGuidReference(context, type)}}; } public static nint Vtable @@ -466,6 +463,8 @@ public static void WriteInterfaceMarshaller(IndentedTextWriter writer, Projectio string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); + WriteIidGuidReferenceCallback iid = AbiTypeHelpers.WriteIidGuidReference(context, type); + writer.WriteLine(); writer.Write(isMultiline: true, $$""" #nullable enable @@ -482,10 +481,8 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged( """); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(">.ConvertToUnmanaged(value, "); - AbiTypeHelpers.WriteIidGuidReference(writer, context, type); - writer.Write(isMultiline: true, """ - ); + writer.Write($$""" + >.ConvertToUnmanaged(value, {{iid}}); } public static diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidReferenceCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidReferenceCallback.cs new file mode 100644 index 000000000..c389655b5 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidReferenceCallback.cs @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteIidGuidReferenceCallback(ProjectionEmitContext context, TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + AbiTypeHelpers.WriteIidGuidReference(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index ee5a670ab..0450376d6 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -5,6 +5,7 @@ using System.Globalization; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; @@ -193,6 +194,21 @@ internal static string GetReturnSizeParamName(MethodSignatureInfo sig) return map; } + /// + /// Returns a that, when used as an interpolation + /// hole in an interpolated raw string, writes the IID GUID literal expression for the given + /// runtime type. Use this overload when emitting the IID inline as part of a larger + /// interpolated raw string (e.g. inside a property declaration or a method invocation), + /// rather than as a standalone write. + /// + /// The active emit context. + /// The runtime type whose IID GUID literal is being written. + /// A callback that writes the IID expression to the writer it's appended to. + public static WriteIidGuidReferenceCallback WriteIidGuidReference(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + /// /// Writes the IID GUID literal expression for the given runtime type (used by ABI emission paths). /// diff --git a/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallback.cs b/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallback.cs new file mode 100644 index 000000000..c6858ef94 --- /dev/null +++ b/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallback.cs @@ -0,0 +1,25 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.Writers; + +/// +/// A callback that writes content into an . Implemented by +/// readonly value-type closures (typically constructed via factory methods on the relevant +/// helper class) so they can be passed as interpolation holes in +/// +/// (or any other handler-overload) and dispatched by +/// +/// without going through a ToString() intermediate. This keeps caller-side emission +/// as a single readable interpolated raw string while still producing zero-allocation, +/// indentation-aware output. +/// +internal interface IIndentedTextWriterCallback +{ + /// + /// Writes the callback's content into at the writer's current + /// position and indentation level. + /// + /// The writer to emit content to. + void Write(IndentedTextWriter writer); +} diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index 863ea023f..4b3d0f8c6 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -6,6 +6,8 @@ using System.Runtime.CompilerServices; using System.Text; +#pragma warning disable IDE0038 + namespace WindowsRuntime.ProjectionWriter.Writers; /// @@ -71,6 +73,14 @@ public void AppendFormatted(T value) return; } + // Handle custom callbacks first (these are only value types) + if (typeof(T).IsValueType && value is IIndentedTextWriterCallback) + { + ((IIndentedTextWriterCallback)value).Write(_writer); + + return; + } + // If the value is a 'string', write it while preserving the multiline semantics. // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) @@ -130,3 +140,4 @@ public void AppendFormatted(string? value) } } } + diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs index b3041d2ce..93900d578 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs @@ -6,6 +6,8 @@ using System.Runtime.CompilerServices; using System.Text; +#pragma warning disable IDE0038 + namespace WindowsRuntime.ProjectionWriter.Writers; /// @@ -110,6 +112,14 @@ public void AppendFormatted(T value) return; } + // Handle custom callbacks first (these are only value types) + if (typeof(T).IsValueType && value is IIndentedTextWriterCallback) + { + ((IIndentedTextWriterCallback)value).Write(_writer); + + return; + } + // If the value is a 'string', write it while preserving the multiline semantics. // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) From b7d101d2cc21709a066ae58cf4d778fc98c12fe1 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:25:32 -0700 Subject: [PATCH 012/171] Add IIndentedTextWriterCallback Format() extension Add an extension method that, given any value-type implementation of IIndentedTextWriterCallback, leases an IndentedTextWriter from the pool, invokes the callback against it, and returns the resulting string. Use this overload when the caller needs the emitted text as a standalone string (e.g. to compose into another string or pass through APIs that take string), rather than appending it inline as an interpolation hole inside a larger writer call. Currently unused; subsequent commits will introduce additional callbacks and migrate existing string-returning helpers to call factory(...).Format() instead of duplicating the leased-pool boilerplate. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../IIndentedTextWriterCallbackExtensions.cs | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs diff --git a/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs b/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs new file mode 100644 index 000000000..a746cd82a --- /dev/null +++ b/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs @@ -0,0 +1,28 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.Writers; + +/// +/// Extension methods for implementations. +/// +internal static class IIndentedTextWriterCallbackExtensions +{ + /// + /// Writes the callback's content into a pooled at indent + /// level 0 and returns the resulting string. Use this overload when the caller needs + /// the emitted text as a standalone string (for example, to compose into another string or + /// to pass through APIs that take ) rather than appending it inline as + /// an interpolation hole inside a larger writer call. + /// + /// The concrete callback value type. + /// The callback to invoke. + /// The string produced by the callback. + public static string Format(this T callback) + where T : struct, IIndentedTextWriterCallback + { + using IndentedTextWriterOwner owner = IndentedTextWriterPool.GetOrCreate(); + callback.Write(owner.Writer); + return owner.Writer.ToString(); + } +} From 483ca1cd10c15e215898c993d6f075ef160927f4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:26:58 -0700 Subject: [PATCH 013/171] Add WriteTypedefName/WriteTypeParams callbacks and migrate string callers Add two new IIndentedTextWriterCallback implementations that mirror the existing writer-taking factory methods on TypedefNameWriter: - WriteTypedefNameCallback wraps WriteTypedefName(IndentedTextWriter, ProjectionEmitContext, TypeDefinition, TypedefNameType, bool). - WriteTypeParamsCallback wraps WriteTypeParams(IndentedTextWriter, TypeDefinition). Each comes with a callback-returning factory method on TypedefNameWriter that uses '' on the corresponding writer-taking factory so the doc surface stays in one place. The existing callback-returning WriteIidGuidReference factory on AbiTypeHelpers gets the same '' treatment for consistency. Adding the callback-returning WriteTypedefName overload at the same signature as the existing string-returning helper would conflict on return type (C# does not allow return-type-only overloads), so the string-returning WriteTypedefName(ProjectionEmitContext, ...) overload is removed and its 8 callers are migrated to call the new factory and invoke the IIndentedTextWriterCallback.Format() extension method to get the standalone string. The dead StartsWith(GlobalPrefix) defensive checks at each call site are also dropped: every caller passed 'forceWriteNamespace: true', and the writer-taking method always emits the 'global::' prefix when that flag is set, so the defensive fallback branch was unreachable. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario (validated against the post-handler-fix baseline). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 16 ++------- .../Factories/AbiInterfaceFactory.cs | 8 +---- .../Factories/AbiInterfaceIDicFactory.cs | 23 ++----------- .../Callbacks/WriteTypeParamsCallback.cs | 18 ++++++++++ .../Callbacks/WriteTypedefNameCallback.cs | 25 ++++++++++++++ .../Factories/ClassFactory.cs | 8 +---- ...assMembersFactory.WriteInterfaceMembers.cs | 7 +--- .../Helpers/AbiTypeHelpers.cs | 10 +----- .../Helpers/TypedefNameWriter.cs | 33 +++++++++---------- 9 files changed, 67 insertions(+), 81 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeParamsCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 6d5cd09b9..8caba4b9f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -1,7 +1,6 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using System; using AsmResolver.DotNet; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; @@ -9,7 +8,6 @@ using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; -using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -100,12 +98,7 @@ private static int Invoke( // Reuse the interface Do_Abi body emitter: delegates dispatch via __target.Invoke(...), // which is exactly the same shape as interface CCW dispatch. Pass the delegate's // projected name as 'ifaceFullName' and "Invoke" as 'methodName'. - string projectedDelegateForBody = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); - - if (!projectedDelegateForBody.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - projectedDelegateForBody = GlobalPrefix + projectedDelegateForBody; - } + string projectedDelegateForBody = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); AbiMethodBodyFactory.EmitDoAbiBodyIfSimple(writer, context, sig, projectedDelegateForBody, "Invoke"); writer.WriteLine(); @@ -262,12 +255,7 @@ public static void WriteDelegateEventSourceSubclass(IndentedTextWriter writer, P string nameStripped = IdentifierEscaping.StripBackticks(name); // Compute the projected type name (with global::) used as the generic argument. - string projectedName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); - - if (!projectedName.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - projectedName = GlobalPrefix + projectedName; - } + string projectedName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); writer.WriteLine(); writer.Write(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index b50a87ede..d09bc6c27 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -1,7 +1,6 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using System; using System.Collections.Generic; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; @@ -333,12 +332,7 @@ public static nint Vtable } else { - ifaceFullName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); - - if (!ifaceFullName.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - ifaceFullName = GlobalPrefix + ifaceFullName; - } + ifaceFullName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); } // Build a map of event add/remove methods to their event so we can emit the table field diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index e9a169dac..73e490c36 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -1,7 +1,6 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using System; using System.Collections.Generic; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; @@ -10,7 +9,6 @@ using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; -using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -293,12 +291,7 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented { // The CCW interface name (the projected interface name with global:: prefix). For the // delegating thunks we cast through this same projected interface type. - string ccwIfaceName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); - - if (!ccwIfaceName.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - ccwIfaceName = GlobalPrefix + ccwIfaceName; - } + string ccwIfaceName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); foreach (MethodDefinition method in type.Methods) { @@ -427,20 +420,10 @@ internal static void EmitDicShimMappedBclForwarders(IndentedTextWriter writer, P internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { // The CCW interface name (the projected interface name with global:: prefix). - string ccwIfaceName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); - - if (!ccwIfaceName.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - ccwIfaceName = GlobalPrefix + ccwIfaceName; - } + string ccwIfaceName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); // The static ABI Methods class name. - string abiClass = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.StaticAbiClass, true); - - if (!abiClass.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - abiClass = GlobalPrefix + abiClass; - } + string abiClass = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.StaticAbiClass, true).Format(); foreach (MethodDefinition method in type.Methods) { diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeParamsCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeParamsCallback.cs new file mode 100644 index 000000000..15c08de11 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeParamsCallback.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteTypeParamsCallback(TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + TypedefNameWriter.WriteTypeParams(writer, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameCallback.cs new file mode 100644 index 000000000..3aa41e5aa --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameCallback.cs @@ -0,0 +1,25 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteTypedefNameCallback( + ProjectionEmitContext context, + TypeDefinition type, + TypedefNameType nameType, + bool forceWriteNamespace) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + TypedefNameWriter.WriteTypedefName(writer, context, type, nameType, forceWriteNamespace); + } +} + diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 5b1a6340e..beb4c1dcb 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -10,7 +10,6 @@ using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; -using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -330,12 +329,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection // Compute the objref name for this static factory interface. string objRef = ObjRefNameGenerator.GetObjRefName(context, staticIface); // Compute the ABI Methods static class name (e.g. "global::ABI.Windows.System.ILauncherStaticsMethods") - string abiClass = TypedefNameWriter.WriteTypedefName(context, staticIface, TypedefNameType.StaticAbiClass, true); - - if (!abiClass.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - abiClass = GlobalPrefix + abiClass; - } + string abiClass = TypedefNameWriter.WriteTypedefName(context, staticIface, TypedefNameType.StaticAbiClass, true).Format(); // Emit the lazy static objref field (mirrors truth's pattern) once per static iface. if (emittedObjRefs.Add(objRef)) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 5fb953312..695631d75 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -226,12 +226,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // — note this is the ungenerified Methods class for generic interfaces // The _objRef_ field name uses the full instantiated interface name so generic instantiations // (e.g. IAsyncOperation) get a per-instantiation field. - string abiClass = TypedefNameWriter.WriteTypedefName(context, abiInterface, TypedefNameType.StaticAbiClass, true); - - if (!abiClass.StartsWith(GlobalPrefix, StringComparison.Ordinal)) - { - abiClass = GlobalPrefix + abiClass; - } + string abiClass = TypedefNameWriter.WriteTypedefName(context, abiInterface, TypedefNameType.StaticAbiClass, true).Format(); string objRef = ObjRefNameGenerator.GetObjRefName(context, abiInterfaceRef); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 0450376d6..7509c922c 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -194,15 +194,7 @@ internal static string GetReturnSizeParamName(MethodSignatureInfo sig) return map; } - /// - /// Returns a that, when used as an interpolation - /// hole in an interpolated raw string, writes the IID GUID literal expression for the given - /// runtime type. Use this overload when emitting the IID inline as part of a larger - /// interpolated raw string (e.g. inside a property declaration or a method invocation), - /// rather than as a standalone write. - /// - /// The active emit context. - /// The runtime type whose IID GUID literal is being written. + /// /// A callback that writes the IID expression to the writer it's appended to. public static WriteIidGuidReferenceCallback WriteIidGuidReference(ProjectionEmitContext context, TypeDefinition type) { diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 1797eac25..99a1071d3 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -4,6 +4,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Writers; @@ -119,24 +120,6 @@ public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitCon } } - /// - /// Convenience overload of - /// that leases an from , - /// emits the typedef name into it, and returns the resulting string. - /// - /// The active emit context. - /// The type definition to emit the name of. - /// The kind of name to emit (projected, non-projected, ABI, etc.). - /// When , always prepend the global::-qualified namespace prefix. - /// The emitted typedef name. - public static string WriteTypedefName(ProjectionEmitContext context, TypeDefinition type, TypedefNameType nameType = TypedefNameType.Projected, bool forceWriteNamespace = false) - { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteTypedefName(writer, context, type, nameType, forceWriteNamespace); - return writer.ToString(); - } - /// /// Convenience helper that emits the typedef name immediately followed by the generic /// parameter list (e.g. Foo<T0, T1>) into a pooled writer and returns the @@ -158,6 +141,13 @@ public static string WriteTypedefNameWithTypeParams(ProjectionEmitContext contex return writer.ToString(); } + /// + /// A callback that writes the typedef name to the writer it's appended to. + public static WriteTypedefNameCallback WriteTypedefName(ProjectionEmitContext context, TypeDefinition type, TypedefNameType nameType, bool forceWriteNamespace) + { + return new(context, type, nameType, forceWriteNamespace); + } + /// /// Writes <T1, T2> for generic types. /// @@ -181,6 +171,13 @@ public static void WriteTypeParams(IndentedTextWriter writer, TypeDefinition typ writer.Write(">"); } + /// + /// A callback that writes the generic-parameter list to the writer it's appended to. + public static WriteTypeParamsCallback WriteTypeParams(TypeDefinition type) + { + return new(type); + } + /// /// Writes the typedef name + generic params for a handle. /// From e08b488aecb32303a2839f6adfbd1d94b907ef26 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:28:00 -0700 Subject: [PATCH 014/171] Refactor WriteInterfaceMarshaller to use callback interpolation holes The marshaller emission previously broke a single coherent class declaration into nine separate writer calls (six string literals plus five WriteTypedefName/WriteTypeParams pairs) so it could splice the projected type name into multiple positions inside the body. Each literal segment had to manually carry its own interior indentation, which made the layout fragile and hid the underlying shape of the emitted class. Replace the chunked emission with a single multiline interpolated raw string. The callbacks for the three repeated holes are constructed once as locals and embedded inline: - WriteTypedefNameCallback for the projected type name (used 4 times) - WriteTypeParamsCallback for the generic parameter list (used 4 times) - WriteIidGuidReferenceCallback for the IID GUID literal (used 1 time) The new form preserves the existing zero-allocation behavior (the callbacks dispatch through IIndentedTextWriterCallback at interpolation time) while making the emitted class shape readable at the call site. Side effect: this also fixes a latent indent bug in the previous chunked emission. The non-isMultiline 'writer.Write($$..."""...""")' call between the inner WriteTypedefName/WriteTypeParams pair and the trailing 'public static ...' segment was emitting its literal interior as raw text, which prepended only the writer's class-level indent (4 spaces) to the closing '}' of ConvertToUnmanaged and to the next 'public static' declaration, leaving them at column 4 while the matching opening '{' of ConvertToManaged ended up at column 8. The single multiline raw string with isMultiline routing fixes the indentation so every member inside the class is uniformly at column 8. Output diffs against the post-handler-fix baseline are limited to the four files containing non-exclusive non-generic projected interfaces (TestComponent.cs, TestComponentCSharp.cs, TestComponentCSharp.TestPublicExclusiveTo.cs, TestComponentCSharp.Windows.cs); each diff is the indent-fix described above. The generated sources still parse cleanly. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceFactory.cs | 34 +++++-------------- 1 file changed, 8 insertions(+), 26 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index d09bc6c27..422f63200 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -457,41 +457,23 @@ public static void WriteInterfaceMarshaller(IndentedTextWriter writer, Projectio string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); + WriteTypedefNameCallback typedefName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, false); + WriteTypeParamsCallback typeParams = TypedefNameWriter.WriteTypeParams(type); WriteIidGuidReferenceCallback iid = AbiTypeHelpers.WriteIidGuidReference(context, type); writer.WriteLine(); - writer.Write(isMultiline: true, $$""" + writer.WriteLine(isMultiline: true, $$""" #nullable enable public static unsafe class {{nameStripped}}Marshaller { - public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged( - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(isMultiline: true, """ - value) + public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{typedefName}}{{typeParams}} value) { - return WindowsRuntimeInterfaceMarshaller< - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write($$""" - >.ConvertToUnmanaged(value, {{iid}}); + return WindowsRuntimeInterfaceMarshaller<{{typedefName}}{{typeParams}}>.ConvertToUnmanaged(value, {{iid}}); } - - public static - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(isMultiline: true, """ - ? ConvertToManaged(void* value) + + public static {{typedefName}}{{typeParams}}? ConvertToManaged(void* value) { - return ( - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine(isMultiline: true, """ - ?) WindowsRuntimeObjectMarshaller.ConvertToManaged(value); + return ({{typedefName}}{{typeParams}}?) WindowsRuntimeObjectMarshaller.ConvertToManaged(value); } } #nullable disable From d5afe0db81a32c03b33f6521c840399ef82fe6bd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:29:48 -0700 Subject: [PATCH 015/171] Rename TryAppendInterpolatedStringHandler -> AppendIf Rename the interpolated string handler type and file from TryAppendInterpolatedStringHandler to AppendIfInterpolatedStringHandler, updating constructor names and all references in IndentedTextWriter (WriteIf/WriteLineIf signatures). Also apply a tiny formatting tweak in IIndentedTextWriterCallbackExtensions.cs (spacing around callback.Write). This aligns the handler name with its semantics and keeps usages consistent. --- .../Writers/IIndentedTextWriterCallbackExtensions.cs | 2 ++ ...dentedTextWriter.AppendIfInterpolatedStringHandler.cs} | 6 +++--- src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs | 8 ++++---- 3 files changed, 9 insertions(+), 7 deletions(-) rename src/WinRT.Projection.Writer/Writers/{IndentedTextWriter.TryAppendInterpolatedStringHandler.cs => IndentedTextWriter.AppendIfInterpolatedStringHandler.cs} (97%) diff --git a/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs b/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs index a746cd82a..2f2453216 100644 --- a/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs +++ b/src/WinRT.Projection.Writer/Writers/IIndentedTextWriterCallbackExtensions.cs @@ -22,7 +22,9 @@ public static string Format(this T callback) where T : struct, IIndentedTextWriterCallback { using IndentedTextWriterOwner owner = IndentedTextWriterPool.GetOrCreate(); + callback.Write(owner.Writer); + return owner.Writer.ToString(); } } diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs similarity index 97% rename from src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs rename to src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs index 93900d578..18a80edfb 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.TryAppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs @@ -23,7 +23,7 @@ internal partial class IndentedTextWriter /// [EditorBrowsable(EditorBrowsableState.Never)] [InterpolatedStringHandler] - public readonly ref struct TryAppendInterpolatedStringHandler + public readonly ref struct AppendIfInterpolatedStringHandler { /// The associated to which to append. private readonly IndentedTextWriter _writer; @@ -38,7 +38,7 @@ public readonly ref struct TryAppendInterpolatedStringHandler /// When , writes the content, otherwise it does nothing. /// Whether the handler is enabled. /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. - public TryAppendInterpolatedStringHandler( + public AppendIfInterpolatedStringHandler( int literalLength, int formattedCount, IndentedTextWriter writer, @@ -71,7 +71,7 @@ public TryAppendInterpolatedStringHandler( /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). /// Whether the handler is enabled. /// This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly. - public TryAppendInterpolatedStringHandler( + public AppendIfInterpolatedStringHandler( int literalLength, int formattedCount, IndentedTextWriter writer, diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index a0299eff5..c098adb36 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -227,7 +227,7 @@ public void Write(bool isMultiline, ReadOnlySpan content) /// When , writes ; otherwise this call is a no-op. /// The interpolated content to write. /// - public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref TryAppendInterpolatedStringHandler handler) + public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref AppendIfInterpolatedStringHandler handler) { _ = this; } @@ -239,7 +239,7 @@ public void WriteIf(bool condition, [InterpolatedStringHandlerArgument("", nameo /// When , treats as multiline. /// The interpolated content to write. /// - public void WriteIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref TryAppendInterpolatedStringHandler handler) + public void WriteIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref AppendIfInterpolatedStringHandler handler) { _ = this; } @@ -413,7 +413,7 @@ public void WriteLineIf(bool condition, bool skipIfPresent = false) /// When , writes +newline; otherwise this call is a no-op. /// The interpolated content to write. /// - public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref TryAppendInterpolatedStringHandler handler) + public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", nameof(condition))] ref AppendIfInterpolatedStringHandler handler) { _ = this; } @@ -425,7 +425,7 @@ public void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("", n /// When , treats as multiline. /// The interpolated content to write. /// - public void WriteLineIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref TryAppendInterpolatedStringHandler handler) + public void WriteLineIf(bool condition, bool isMultiline, [InterpolatedStringHandlerArgument("", nameof(condition), nameof(isMultiline))] ref AppendIfInterpolatedStringHandler handler) { if (condition) { From 3331f927009cea01442c292a880a494f95cceab0 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:48:10 -0700 Subject: [PATCH 016/171] Add interface-typed callback dispatch to AppendFormatted Add a polymorphic dispatch path to AppendFormatted on both the AppendInterpolatedStringHandler and AppendIfInterpolatedStringHandler so callers can declare a local of type IIndentedTextWriterCallback (rather than a concrete callback struct) and assign one of several concrete callback values based on a runtime condition. The local can then be embedded as an interpolation hole in the same way the existing value-type callbacks are. The existing 'typeof(T).IsValueType && value is IIndentedTextWriterCallback' fast path is preserved unchanged: when 'T' is a concrete callback struct (the common case) the JIT can constant-fold the type checks and elide the polymorphic branch entirely. The new branch only fires when 'T' is the interface type itself (or some other reference type that happens to implement the interface), which is the case where the caller wanted polymorphic behavior in the first place. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- ...edTextWriter.AppendIfInterpolatedStringHandler.cs | 12 +++++++++++- ...ntedTextWriter.AppendInterpolatedStringHandler.cs | 12 +++++++++++- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs index 18a80edfb..a64fc0fe4 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendIfInterpolatedStringHandler.cs @@ -112,7 +112,8 @@ public void AppendFormatted(T value) return; } - // Handle custom callbacks first (these are only value types) + // Handle custom callbacks first. The value-type fast path lets the JIT specialize + // the dispatch when 'T' is the concrete callback struct (e.g. WriteIidGuidReferenceCallback). if (typeof(T).IsValueType && value is IIndentedTextWriterCallback) { ((IIndentedTextWriterCallback)value).Write(_writer); @@ -120,6 +121,15 @@ public void AppendFormatted(T value) return; } + // Polymorphic fallback for callers that declare the local as the interface type + // (e.g. to assign one of several concrete callback structs based on a condition). + if (value is IIndentedTextWriterCallback callback) + { + callback.Write(_writer); + + return; + } + // If the value is a 'string', write it while preserving the multiline semantics. // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index 4b3d0f8c6..5583cfc09 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -73,7 +73,8 @@ public void AppendFormatted(T value) return; } - // Handle custom callbacks first (these are only value types) + // Handle custom callbacks first. The value-type fast path lets the JIT specialize + // the dispatch when 'T' is the concrete callback struct (e.g. WriteIidGuidReferenceCallback). if (typeof(T).IsValueType && value is IIndentedTextWriterCallback) { ((IIndentedTextWriterCallback)value).Write(_writer); @@ -81,6 +82,15 @@ public void AppendFormatted(T value) return; } + // Polymorphic fallback for callers that declare the local as the interface type + // (e.g. to assign one of several concrete callback structs based on a condition). + if (value is IIndentedTextWriterCallback callback) + { + callback.Write(_writer); + + return; + } + // If the value is a 'string', write it while preserving the multiline semantics. // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) From 476a9365b5d4a5e263c32ee43e6b1161bdae1b90 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:49:23 -0700 Subject: [PATCH 017/171] Add WriteTypedefNameWithTypeParams writer + callback and migrate string callers Add the missing writer-taking method 'WriteTypedefNameWithTypeParams( IndentedTextWriter, ProjectionEmitContext, TypeDefinition, TypedefNameType, bool)' on TypedefNameWriter, plus a matching WriteTypedefNameWithTypeParamsCallback struct and a callback-returning factory overload that uses '' on the writer-taking method to keep the doc surface in one place. The writer-taking method is a tiny composition of 'WriteTypedefName' and 'WriteTypeParams' (which is exactly what the previous string-returning convenience already did internally) and lets callers emit the typedef-name + generic-parameter list as a single inline operation on a writer. The callback factory wraps it for use as an interpolation hole inside a larger interpolated raw string, mirroring the WriteTypedefName / WriteTypeParams / WriteIidGuidReference pattern. The callback-returning factory occupies the same signature as the previous string-returning 'WriteTypedefNameWithTypeParams' overload, so the string-returning version is removed and its 6 callers (in ComponentFactory, IidExpressionGenerator, MetadataAttributeFactory) are migrated to call the new factory and chain '.Format()' to get the standalone string. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../WriteTypedefNameWithTypeParamsCallback.cs | 24 +++++++++++++++++++ .../Factories/ComponentFactory.cs | 4 ++-- .../Factories/MetadataAttributeFactory.cs | 4 ++-- .../Helpers/IidExpressionGenerator.cs | 4 ++-- .../Helpers/TypedefNameWriter.cs | 19 ++++++++------- 5 files changed, 41 insertions(+), 14 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameWithTypeParamsCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameWithTypeParamsCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameWithTypeParamsCallback.cs new file mode 100644 index 000000000..194b90b7f --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypedefNameWithTypeParamsCallback.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteTypedefNameWithTypeParamsCallback( + ProjectionEmitContext context, + TypeDefinition type, + TypedefNameType nameType, + bool forceWriteNamespace) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + TypedefNameWriter.WriteTypedefNameWithTypeParams(writer, context, type, nameType, forceWriteNamespace); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 7923a9066..440a28bcf 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -36,9 +36,9 @@ public static void AddMetadataTypeEntry(ProjectionEmitContext context, TypeDefin return; } - string typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); + string typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true).Format(); - string metadataTypeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.CCW, true); + string metadataTypeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.CCW, true).Format(); _ = map.TryAdd(typeName, metadataTypeName); } diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 5abdda07b..83540b0b2 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -206,7 +206,7 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent } // Capture the projected type name as a string by writing into a scratch writer at indent 0. - string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true).Format(); writer.WriteLine(); writer.Write(isMultiline: true, $$""" @@ -254,7 +254,7 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent /// When , wraps the projected type in Windows.Foundation.IReference`1<...>. public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, bool isValueType) { - string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true).Format(); writer.WriteLine(); writer.Write(isMultiline: true, """ diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 32a0fea92..d65d8235f 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -174,7 +174,7 @@ private static void WriteByte(IndentedTextWriter writer, uint b, bool first) /// public static void WriteIidGuidPropertyName(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = EscapeTypeNameForIdentifier(TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true), true, true); + string name = EscapeTypeNameForIdentifier(TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true).Format(), true, true); writer.Write($"IID_{name}"); } @@ -183,7 +183,7 @@ public static void WriteIidGuidPropertyName(IndentedTextWriter writer, Projectio /// public static void WriteIidReferenceGuidPropertyName(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = EscapeTypeNameForIdentifier(TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true), true, true); + string name = EscapeTypeNameForIdentifier(TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true).Format(), true, true); writer.Write($"IID_{name}Reference"); } diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 99a1071d3..156d5fb6f 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -121,24 +121,27 @@ public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitCon } /// - /// Convenience helper that emits the typedef name immediately followed by the generic - /// parameter list (e.g. Foo<T0, T1>) into a pooled writer and returns the - /// resulting string. Equivalent to calling + /// Writes the typedef name immediately followed by the generic parameter list + /// (e.g. Foo<T0, T1>). Equivalent to calling /// /// followed by . /// + /// The writer to emit to. /// The active emit context. /// The (potentially generic) type definition. /// The kind of name to emit. /// When , always prepend the global::-qualified namespace prefix. - /// The emitted typedef name + generic-parameter list. - public static string WriteTypedefNameWithTypeParams(ProjectionEmitContext context, TypeDefinition type, TypedefNameType nameType = TypedefNameType.Projected, bool forceWriteNamespace = false) + public static void WriteTypedefNameWithTypeParams(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypedefNameType nameType, bool forceWriteNamespace) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; WriteTypedefName(writer, context, type, nameType, forceWriteNamespace); WriteTypeParams(writer, type); - return writer.ToString(); + } + + /// + /// A callback that writes the typedef name + generic-parameter list to the writer it's appended to. + public static WriteTypedefNameWithTypeParamsCallback WriteTypedefNameWithTypeParams(ProjectionEmitContext context, TypeDefinition type, TypedefNameType nameType, bool forceWriteNamespace) + { + return new(context, type, nameType, forceWriteNamespace); } /// From de1c6a7d9d7c95dd0b4f6e5a80ddca0ed445aaef Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:50:20 -0700 Subject: [PATCH 018/171] Refactor MetadataAttributeFactory to use callback interpolation holes Replace the chunked '[opener]; WriteTypedefName; WriteTypeParams; [closer]' emission pattern in five attribute writers with single interpolated raw strings that embed the typedef-name + generic-params emission as interpolation holes (using WriteTypedefNameWithTypeParamsCallback and the existing WriteIid / WriteTypedefName / WriteTypeParams callbacks). The resulting attribute text is now legible at the call site, and conditional pieces inside the template are prepared as locals before the writer call so the '$$"""..."""' block stays whole. The methods updated are: - WriteWinRTMetadataTypeNameAttribute, WriteWinRTMappedTypeAttribute, WriteWinRTReferenceTypeAttribute: simple one-liners now built as a single interpolated WriteLine. - WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute and WriteWinRTComWrappersTypeMapGroupAssemblyAttribute: the 'target:' typeof slot toggles between the ABI typedef and the projected typedef based on 'context.Settings.Component'; both branches yield WriteTypedefNameWithTypeParamsCallback values that get selected into a value-typed local. The 'value:' string-literal slot in the ComWrappers attribute toggles between an 'IReference`1<...>' wrapper and the bare projection name; both branches yield strings, so a plain 'string' local is used. - WriteWinRTIdicTypeMapGroupAssemblyAttribute: two distinct callbacks (Projected source, ABI proxy) prepared as locals and embedded in a single interpolated raw string. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario; the generated sources still parse cleanly. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/MetadataAttributeFactory.cs | 112 ++++++------------ 1 file changed, 37 insertions(+), 75 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 83540b0b2..49d0599c0 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -8,6 +8,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Builders; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -116,10 +117,9 @@ public static void WriteWinRTMetadataAttribute(IndentedTextWriter writer, TypeDe /// The type definition. public static void WriteWinRTMetadataTypeNameAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - writer.Write("[WindowsRuntimeMetadataTypeName(\""); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine("\")]"); + WriteTypedefNameWithTypeParamsCallback typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + + writer.WriteLine($"""[WindowsRuntimeMetadataTypeName("{typeName}")]"""); } /// @@ -130,10 +130,9 @@ public static void WriteWinRTMetadataTypeNameAttribute(IndentedTextWriter writer /// The type definition. public static void WriteWinRTMappedTypeAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - writer.Write("[WindowsRuntimeMappedType(typeof("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine("))]"); + WriteTypedefNameWithTypeParamsCallback typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); + + writer.WriteLine($"[WindowsRuntimeMappedType(typeof({typeName}))]"); } /// @@ -166,10 +165,9 @@ public static void WriteWinRTReferenceTypeAttribute(IndentedTextWriter writer, P return; } - writer.Write("[WindowsRuntimeReferenceType(typeof("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine("?))]"); + WriteTypedefNameWithTypeParamsCallback typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); + + writer.WriteLine($"[WindowsRuntimeReferenceType(typeof({typeName}?))]"); } /// @@ -208,38 +206,27 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent // Capture the projected type name as a string by writing into a scratch writer at indent 0. string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true).Format(); + // The 'target:' slot is the ABI typedef name in component mode, otherwise the projected name. + WriteTypedefNameWithTypeParamsCallback target = context.Settings.Component + ? TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true) + : TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + writer.WriteLine(); - writer.Write(isMultiline: true, $$""" + writer.WriteLine(isMultiline: true, $$""" [assembly: TypeMap( value: "{{projectionName}}", - target: typeof( - """); - if (context.Settings.Component) - { - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); - TypedefNameWriter.WriteTypeParams(writer, type); - } - else - { - writer.Write(projectionName); - } - - writer.WriteLine(isMultiline: true, $$""" - ), + target: typeof({{target}}), trimTarget: typeof({{projectionName}}))] """); if (context.Settings.Component) { writer.WriteLine(); - writer.Write(isMultiline: true, $$""" + writer.WriteLine(isMultiline: true, $$""" [assembly: TypeMapAssociation( source: typeof({{projectionName}}), - proxy: typeof( + proxy: typeof({{target}}))] """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine("))]"); writer.WriteLine(); } } @@ -256,36 +243,19 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe { string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true).Format(); - writer.WriteLine(); - writer.Write(isMultiline: true, """ - [assembly: TypeMap( - value: " - """); - if (isValueType) - { - writer.Write($"Windows.Foundation.IReference`1<{projectionName}>"); - } - else - { - writer.Write(projectionName); - } + // The 'value:' slot is wrapped in 'Windows.Foundation.IReference`1<...>' for value types. + string value = isValueType ? $"Windows.Foundation.IReference`1<{projectionName}>" : projectionName; - writer.Write(isMultiline: true, """ - ", - target: typeof( - """); - if (context.Settings.Component) - { - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); - TypedefNameWriter.WriteTypeParams(writer, type); - } - else - { - writer.Write(projectionName); - } + // The 'target:' slot is the ABI typedef name in component mode, otherwise the projected name. + WriteTypedefNameWithTypeParamsCallback target = context.Settings.Component + ? TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true) + : TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - ), + [assembly: TypeMap( + value: "{{value}}", + target: typeof({{target}}), trimTarget: typeof({{projectionName}}))] """); @@ -295,14 +265,11 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe if (cat is not (TypeCategory.Interface or TypeCategory.Struct) && context.Settings.Component) { writer.WriteLine(); - writer.Write(isMultiline: true, $$""" + writer.WriteLine(isMultiline: true, $$""" [assembly: TypeMapAssociation( source: typeof({{projectionName}}), - proxy: typeof( + proxy: typeof({{target}}))] """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine("))]"); writer.WriteLine(); } } @@ -329,20 +296,15 @@ public static void WriteWinRTIdicTypeMapGroupAssemblyAttribute(IndentedTextWrite return; } + WriteTypedefNameWithTypeParamsCallback source = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); + WriteTypedefNameWithTypeParamsCallback proxy = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true); + writer.WriteLine(); - writer.Write(isMultiline: true, """ + writer.WriteLine(isMultiline: true, $$""" [assembly: TypeMapAssociation( - source: typeof( - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(isMultiline: true, """ - ), - proxy: typeof( + source: typeof({{source}}), + proxy: typeof({{proxy}}))] """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine("))]"); writer.WriteLine(); } From d5455856462e3d2a4aca282be3fb65e8b9442e7f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 16:53:51 -0700 Subject: [PATCH 019/171] Merge EmitDicShim*Forwarders into single interpolated raw strings Both EmitDicShimIObservableMapForwarders and EmitDicShimIObservableVectorForwarders previously split their emission into two separate WriteLine(isMultiline: true, $$..."""...""") calls because the second block (the IObservableMap.MapChanged / IObservableVector.VectorChanged event forwarder) needed locals (obsTarget, obsSelf) that weren't available when the first block was emitted. Lift those locals to the top of each method alongside the existing target / self / icoll locals so a single interpolated multiline raw string can carry both blocks separated by a blank line. The output is byte-identical (validated against the post-handler-fix baseline for all 10 generated files in the refgen-pushnot scenario). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 20 ++++++++----------- 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 73e490c36..3d80acab3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -201,6 +201,9 @@ internal static void EmitDicShimIObservableMapForwarders(IndentedTextWriter writ string target = $"((global::System.Collections.Generic.IDictionary<{keyText}, {valueText}>)(WindowsRuntimeObject)this)"; string self = $"global::System.Collections.Generic.IDictionary<{keyText}, {valueText}>."; string icoll = $"global::System.Collections.Generic.ICollection>."; + string obsTarget = $"((global::Windows.Foundation.Collections.IObservableMap<{keyText}, {valueText}>)(WindowsRuntimeObject)this)"; + string obsSelf = $"global::Windows.Foundation.Collections.IObservableMap<{keyText}, {valueText}>."; + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" ICollection<{{keyText}}> {{self}}Keys => {{target}}.Keys; @@ -223,12 +226,7 @@ internal static void EmitDicShimIObservableMapForwarders(IndentedTextWriter writ bool ICollection>.Remove(KeyValuePair<{{keyText}}, {{valueText}}> item) => {{target}}.Remove(item); IEnumerator> IEnumerable>.GetEnumerator() => {{target}}.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - """); - // IObservableMap.MapChanged event forwarder. - string obsTarget = $"((global::Windows.Foundation.Collections.IObservableMap<{keyText}, {valueText}>)(WindowsRuntimeObject)this)"; - string obsSelf = $"global::Windows.Foundation.Collections.IObservableMap<{keyText}, {valueText}>."; - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" + event global::Windows.Foundation.Collections.MapChangedEventHandler<{{keyText}}, {{valueText}}> {{obsSelf}}MapChanged { add => {{obsTarget}}.MapChanged += value; @@ -248,6 +246,9 @@ internal static void EmitDicShimIObservableVectorForwarders(IndentedTextWriter w string target = $"((global::System.Collections.Generic.IList<{elementText}>)(WindowsRuntimeObject)this)"; string self = $"global::System.Collections.Generic.IList<{elementText}>."; string icoll = $"global::System.Collections.Generic.ICollection<{elementText}>."; + string obsTarget = $"((global::Windows.Foundation.Collections.IObservableVector<{elementText}>)(WindowsRuntimeObject)this)"; + string obsSelf = $"global::Windows.Foundation.Collections.IObservableVector<{elementText}>."; + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" int {{icoll}}Count => {{target}}.Count; @@ -267,12 +268,7 @@ internal static void EmitDicShimIObservableVectorForwarders(IndentedTextWriter w bool {{icoll}}Remove({{elementText}} item) => {{target}}.Remove(item); IEnumerator<{{elementText}}> IEnumerable<{{elementText}}>.GetEnumerator() => {{target}}.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - """); - // IObservableVector.VectorChanged event forwarder. - string obsTarget = $"((global::Windows.Foundation.Collections.IObservableVector<{elementText}>)(WindowsRuntimeObject)this)"; - string obsSelf = $"global::Windows.Foundation.Collections.IObservableVector<{elementText}>."; - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" + event global::Windows.Foundation.Collections.VectorChangedEventHandler<{{elementText}}> {{obsSelf}}VectorChanged { add => {{obsTarget}}.VectorChanged += value; From 3dcd3017d8bfa93664e206464c5fd4671b6e6442 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:02:16 -0700 Subject: [PATCH 020/171] Refactor file-interface and static-class declarations to use callbacks Replace the two-line 'writer.Write("...prefix..."); WriteTypedefName; WriteTypeParams; writer.WriteLine()' sequences in AbiInterfaceIDicFactory.WriteIdicFileInterfaceDecl and ClassFactory.WriteStaticClass with a single interpolated 'writer.WriteLine($"...{{name}}")' call that embeds a WriteTypedefNameWithTypeParamsCallback local as the interpolation hole. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 7 +++---- src/WinRT.Projection.Writer/Factories/ClassFactory.cs | 7 +++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 3d80acab3..dbb8e6eb5 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -37,15 +38,13 @@ public static void WriteInterfaceIdicImpl(IndentedTextWriter writer, ProjectionE string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); + WriteTypedefNameWithTypeParamsCallback parent = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); writer.WriteLine(); writer.WriteLine("[DynamicInterfaceCastableImplementation]"); InterfaceFactory.WriteGuidAttribute(writer, type); writer.WriteLine(); - writer.Write($"file interface {nameStripped} : "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine(); + writer.WriteLine($"file interface {nameStripped} : {parent}"); using (writer.WriteBlock()) { // Emit DIM bodies that dispatch through the static ABI Methods class. diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index beb4c1dcb..44c4ee4e5 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Globalization; using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -287,10 +288,8 @@ public static void WriteStaticClass(IndentedTextWriter writer, ProjectionEmitCon { MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); - writer.Write($"{context.Settings.InternalAccessibility} static class "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.WriteLine(); + WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); + writer.WriteLine($"{context.Settings.InternalAccessibility} static class {name}"); using (writer.WriteBlock()) { WriteStaticClassMembers(writer, context, type); From 440b73d912a046c49ffa9a86b0052b0703025cf3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:27:54 -0700 Subject: [PATCH 021/171] Refactor StructEnumMarshallerFactory complex-struct emission to use callbacks Hoist 'WriteTypedefNameCallback' locals for the ABI and projected typedef names at the top of the 'isComplexStruct' branch and use single multiline interpolated raw strings for each of the three method signatures emitted by that branch: - ConvertToUnmanaged({{projected}} value) returning {{abi}} - ConvertToManaged({{abi}} value) returning {{projected}} - Dispose({{abi}} value) The previous emission split each signature across four to six separate writer calls (Write prefix; WriteTypedefName ABI; Write " ConvertToUnmanaged("; WriteTypedefName Projected; WriteLine multiline body opener) so the typedef-name pieces could be spliced into a single declaration line. The new form puts each signature (and its body opener) into one readable multiline raw string with the callback locals embedded as interpolation holes. The 'new {{projected}}{{(useObjectInitializer ? "(){" : "(")}}' hole inlines the existing conditional-suffix choice so the 'return new ...' line stays inside the same raw string as the rest of the body opener instead of being emitted by a follow-up 'writer.WriteLine(useObjectInitializer ? "(){" : "(")' call. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/StructEnumMarshallerFactory.cs | 38 +++++++------------ 1 file changed, 14 insertions(+), 24 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 170204963..21e0d2e2b 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -3,6 +3,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -72,13 +73,12 @@ public static unsafe class {{nameStripped}}Marshaller if (isComplexStruct) { + WriteTypedefNameCallback abi = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, false); + WriteTypedefNameCallback projected = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); + // ConvertToUnmanaged: build ABI struct from projected struct via per-field marshalling. - writer.Write(" public static "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); - writer.Write(" ConvertToUnmanaged("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(isMultiline: true, """ - value) + writer.WriteLine(isMultiline: true, $$""" + public static {{abi}} ConvertToUnmanaged({{projected}} value) { return new() { """); @@ -130,27 +130,19 @@ public static unsafe class {{nameStripped}}Marshaller writer.Write($"value.{fname}"); } } - writer.WriteLine(); - writer.Write(isMultiline: true, """ - }; - } - public static - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.Write(" ConvertToManaged("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); // - In component mode: emit object initializer with named field assignments // (positional ctor not always available on authored types). // - In non-component mode: emit positional constructor (matches the auto-generated // primary constructor on projected struct types). bool useObjectInitializer = context.Settings.Component; - writer.Write(isMultiline: true, """ - value) + writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" + }; + } + public static {{projected}} ConvertToManaged({{abi}} value) { - return new + return new {{projected}}{{(useObjectInitializer ? "(){" : "(")}} """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(useObjectInitializer ? "(){" : "("); first = true; foreach (FieldDefinition field in type.Fields) { @@ -207,10 +199,8 @@ public static writer.WriteLine(); writer.WriteLine(useObjectInitializer ? " };" : " );"); writer.WriteLine(" }"); - writer.Write(" public static void Dispose("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); - writer.WriteLine(isMultiline: true, """ - value) + writer.WriteLine(isMultiline: true, $$""" + public static void Dispose({{abi}} value) { """); foreach (FieldDefinition field in type.Fields) From 77f0950df9cce7fceed97d3d67b54203745fefc9 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:30:38 -0700 Subject: [PATCH 022/171] Refactor StructEnumMarshallerFactory Box/Unbox/CreateObject to use callbacks Hoist the per-type 'abi' and 'projected' WriteTypedefNameCallback locals to the top of WriteStructEnumMarshallerClass so the BoxToUnmanaged, UnboxToManaged, and CreateObject emission paths can share them, then collapse the chunked 'writer.Write([prefix]); WriteTypedefName; writer.Write([infix]); WriteIidReferenceExpression; writer.WriteLine([suffix])' sequences in each emitter into single interpolated multiline raw strings. - BoxToUnmanaged: the two prior branches (enum/almost/complex vs. mapped struct) had identical layout differing only in the CreateComInterfaceFlags value. The single shared template now selects the flag string via the existing 'hasReferenceFields' condition. The string-returning 'ObjRefNameGenerator.WriteIidReferenceExpression(TypeDefinition)' overload supplies the IID hole as a plain string. - UnboxToManaged: the prior 'isEnum || almostBlittable' and 'else' (mapped struct) branches emitted identical bodies (UnboxToManaged of the projected type), so they collapse into one branch. The remaining 'isComplexStruct' branch becomes a single multiline raw string with '{{projected}}' and '{{abi}}' interpolation holes. - CreateObject: each of the two return-statement emitters becomes a single 'writer.WriteLine($"...{{name}}...")'. The complex-struct branch uses a per-call 'abiFq' callback because that site needs 'forceWriteNamespace: true' (whereas the shared 'abi' local uses 'false'). Side effect: this also fixes a latent indent bug in the complex-struct UnboxToManaged branch. The previous chunked emission wrote a multiline opener followed by 'WriteTypedefName(ABI)' + 'writer.Write("? abi = ...")' on what should have been the next line; the writer indent was applied to the multiline lines but not to the typedef-name-then-Write segment, leaving the 'Nested? abi = ...' line at column 4 while the following 'return ...' line was at column 12. The new single multiline raw string aligns both lines to column 12 via uniform writer indent handling. The change is purely whitespace (verified with a Roslyn syntax check) and affects three generated files (Microsoft.Windows. PushNotifications.cs, TestComponent.cs, TestComponentCSharp.cs). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/StructEnumMarshallerFactory.cs | 106 +++++------------- 1 file changed, 29 insertions(+), 77 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 21e0d2e2b..5a669a91c 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -66,6 +66,9 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P isComplexStruct = false; } + WriteTypedefNameCallback abi = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, false); + WriteTypedefNameCallback projected = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); + writer.WriteLine(isMultiline: true, $$""" public static unsafe class {{nameStripped}}Marshaller { @@ -73,9 +76,6 @@ public static unsafe class {{nameStripped}}Marshaller if (isComplexStruct) { - WriteTypedefNameCallback abi = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, false); - WriteTypedefNameCallback projected = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); - // ConvertToUnmanaged: build ABI struct from projected struct via per-field marshalling. writer.WriteLine(isMultiline: true, $$""" public static {{abi}} ConvertToUnmanaged({{projected}} value) @@ -247,87 +247,42 @@ public static void Dispose({{abi}} value) writer.WriteLine(" }"); } - // BoxToUnmanaged: same pattern for all (enum, almost-blittable, complex). + // BoxToUnmanaged: same pattern for all (enum, almost-blittable, complex, mapped struct). // Truth uses CreateComInterfaceFlags.TrackerSupport when the struct has reference type // fields (Nullable, etc.) to avoid GC issues with the boxed managed object reference. - writer.Write(" public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - - if (isEnum || almostBlittable || isComplexStruct) - { - writer.Write(isMultiline: true, $$""" - ? value) - { - return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.{{(hasReferenceFields ? "TrackerSupport" : "None")}}, in - """); - ObjRefNameGenerator.WriteIidReferenceExpression(writer, type); - writer.WriteLine(isMultiline: true, """ - ); - } - """); - } - else - { - // Mapped struct (Duration/KeyTime/etc.): BoxToUnmanaged is still required because the - // public projected type still routes through this marshaller (it just lacks per-field - // ConvertToUnmanaged/ConvertToManaged because the field layout doesn't match). - writer.Write(isMultiline: true, """ - ? value) - { - return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.None, in - """); - ObjRefNameGenerator.WriteIidReferenceExpression(writer, type); - writer.WriteLine(isMultiline: true, """ - ); - } - """); - } + // Mapped struct (Duration/KeyTime/etc.) variants always use None — the public projected + // type still routes through this marshaller (it just lacks per-field + // ConvertToUnmanaged/ConvertToManaged because the field layout doesn't match). + string boxFlags = (isEnum || almostBlittable || isComplexStruct) && hasReferenceFields ? "TrackerSupport" : "None"; + string boxIidRef = ObjRefNameGenerator.WriteIidReferenceExpression(type); - // UnboxToManaged: simple for almost-blittable; for complex, unbox to ABI struct then ConvertToManaged. - writer.Write(" public static "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); + writer.WriteLine(isMultiline: true, $$""" + public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? value) + { + return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.{{boxFlags}}, in {{boxIidRef}}); + } + """); - if (isEnum || almostBlittable) - { - writer.Write(isMultiline: true, """ - ? UnboxToManaged(void* value) - { - return WindowsRuntimeValueTypeMarshaller.UnboxToManaged< - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(isMultiline: true, """ - >(value); - } - """); - } - else if (isComplexStruct) + // UnboxToManaged: simple for almost-blittable and mapped structs; for complex, unbox to + // ABI struct then ConvertToManaged. Mapped struct unboxes directly to projected type (no + // per-field ConvertToManaged needed because the projected struct's field layout matches + // the WinMD struct layout). + if (isComplexStruct) { - writer.WriteLine(isMultiline: true, """ - ? UnboxToManaged(void* value) + writer.WriteLine(isMultiline: true, $$""" + public static {{projected}}? UnboxToManaged(void* value) { - - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); - writer.Write("? abi = WindowsRuntimeValueTypeMarshaller.UnboxToManaged<"); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, false); - writer.WriteLine(isMultiline: true, """ - >(value); + {{abi}}? abi = WindowsRuntimeValueTypeMarshaller.UnboxToManaged<{{abi}}>(value); return abi.HasValue ? ConvertToManaged(abi.GetValueOrDefault()) : null; } """); } else { - // Mapped struct: unbox directly to projected type (no per-field ConvertToManaged needed - // because the projected struct's field layout matches the WinMD struct layout). - writer.Write(isMultiline: true, """ - ? UnboxToManaged(void* value) + writer.WriteLine(isMultiline: true, $$""" + public static {{projected}}? UnboxToManaged(void* value) { - return WindowsRuntimeValueTypeMarshaller.UnboxToManaged< - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(isMultiline: true, """ - >(value); + return WindowsRuntimeValueTypeMarshaller.UnboxToManaged<{{projected}}>(value); } """); } @@ -402,15 +357,12 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper """); if (isComplexStruct) { - writer.Write($" return {nameStripped}Marshaller.ConvertToManaged(WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<"); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.ABI, true); - writer.WriteLine($">(value, in {iidRefExpr}));"); + WriteTypedefNameCallback abiFq = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, true); + writer.WriteLine($" return {nameStripped}Marshaller.ConvertToManaged(WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{abiFq}>(value, in {iidRefExpr}));"); } else { - writer.Write(" return WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<"); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine($">(value, in {iidRefExpr});"); + writer.WriteLine($" return WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{projected}>(value, in {iidRefExpr});"); } writer.WriteLine(isMultiline: true, """ From 1fbde593ef31781002a88de55a69024aebf8323e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:33:17 -0700 Subject: [PATCH 023/171] Add WriteTypeInheritanceCallback and use it in class/interface declarations Add a 1:1 callback wrapper for 'InterfaceFactory.WriteTypeInheritance(IndentedTextWriter, ProjectionEmitContext, TypeDefinition, bool, bool)' (the writer-taking method that emits the ' : Base, Iface1, Iface2' clause for class and interface declarations), plus a paired callback-returning factory overload with '' on the writer-taking method. Use the new callback to collapse the chunked 'writer.Write("...prefix..."); WriteTypedefName; WriteTypeParams; WriteTypeInheritance; writer.WriteLine()' sequences at the two existing class/interface declaration call sites into single interpolated 'writer.WriteLine($"...{{name}}{{inheritance}}")' calls: - InterfaceFactory.WriteInterfaceDeclaration emits '{accessibility} interface {{name}}{{inheritance}}'. - ClassFactory.WriteClassDeclaration emits '{accessibility} {modifiers}class {{name}}{{inheritance}}', with the trivial 'static '/'sealed ' modifier choice inlined as a 'string modifiers' local (rather than going through the 'WriteClassModifiers' writer helper, which still exists for any future caller that needs the writer-side form). Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Callbacks/WriteTypeInheritanceCallback.cs | 22 +++++++++++++++++++ .../Factories/ClassFactory.cs | 12 +++++----- .../Factories/InterfaceFactory.cs | 16 +++++++++----- 3 files changed, 38 insertions(+), 12 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeInheritanceCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeInheritanceCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeInheritanceCallback.cs new file mode 100644 index 000000000..0c9a67ff7 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeInheritanceCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteTypeInheritanceCallback( + ProjectionEmitContext context, + TypeDefinition type, + bool includeExclusiveInterface, + bool includeWindowsRuntimeObject) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + InterfaceFactory.WriteTypeInheritance(writer, context, type, includeExclusiveInterface, includeWindowsRuntimeObject); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 44c4ee4e5..28dfaef00 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -590,14 +590,12 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); - writer.Write($"{(context.Settings.Internal ? "internal" : "public")} "); - WriteClassModifiers(writer, type); + string accessibility = context.Settings.Internal ? "internal" : "public"; // are emitted as plain (non-partial) classes. - writer.Write("class "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - InterfaceFactory.WriteTypeInheritance(writer, context, type, false, true); - writer.WriteLine(); + string modifiers = TypeCategorization.IsStatic(type) ? "static " : type.IsSealed ? "sealed " : ""; + WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); + WriteTypeInheritanceCallback inheritance = InterfaceFactory.WriteTypeInheritance(context, type, false, true); + writer.WriteLine($"{accessibility} {modifiers}class {name}{inheritance}"); using IndentedTextWriter.Block __classBlock = writer.WriteBlock(); // ObjRef field definitions for each implemented interface. diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 9afbc3440..b714a1a64 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -6,6 +6,7 @@ using AsmResolver; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -127,6 +128,13 @@ public static void WriteTypeInheritance(IndentedTextWriter writer, ProjectionEmi } } + /// + /// A callback that writes the inheritance clause to the writer it's appended to. + public static WriteTypeInheritanceCallback WriteTypeInheritance(ProjectionEmitContext context, TypeDefinition type, bool includeExclusiveInterface, bool includeWindowsRuntimeObject) + { + return new(context, type, includeExclusiveInterface, includeWindowsRuntimeObject); + } + /// /// Writes the projected name for an interface reference (TypeDefinition, TypeReference, or /// generic instance), applying mapped-type remapping (e.g., @@ -471,11 +479,9 @@ public static void WriteInterface(IndentedTextWriter writer, ProjectionEmitConte bool isInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) || TypeCategorization.IsProjectionInternal(type); - writer.Write($"{(isInternal ? "internal" : "public")} interface "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.CCW, false); - TypedefNameWriter.WriteTypeParams(writer, type); - WriteTypeInheritance(writer, context, type, false, false); - writer.WriteLine(); + WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.CCW, false); + WriteTypeInheritanceCallback inheritance = WriteTypeInheritance(context, type, false, false); + writer.WriteLine($"{(isInternal ? "internal" : "public")} interface {name}{inheritance}"); using (writer.WriteBlock()) { WriteInterfaceMemberSignatures(writer, context, type); From 0f1a06021f793147c53a873a1ed8d5938c253d3e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:34:02 -0700 Subject: [PATCH 024/171] Refactor ReferenceImplFactory blittable get_Value to use callback Collapse the five-call emission sequence in the blittable / blittable- struct branch of WriteReferenceImpl get_Value (Write opener; WriteTypedefName Projected; Write infix; WriteTypedefName Projected again; WriteLine closer) into a single interpolated multiline raw string with a hoisted WriteTypedefNameCallback local embedded as the type-name interpolation hole in both the cast and the pointer cast. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ReferenceImplFactory.cs | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 7f43d20c7..2a5ea0e7c 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -3,6 +3,7 @@ using AsmResolver.DotNet; using WindowsRuntime.ProjectionWriter.Errors; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -58,7 +59,8 @@ public static nint Vtable { // For blittable types and blittable structs: direct memcpy via C# struct assignment. // Even bool/char fields work because their managed layout matches the WinRT ABI. - writer.Write(isMultiline: true, """ + WriteTypedefNameCallback projected = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true); + writer.WriteLine(isMultiline: true, $$""" public static int get_Value(void* thisPtr, void* result) { if (result is null) @@ -68,16 +70,8 @@ public static int get_Value(void* thisPtr, void* result) try { - var value = ( - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.Write(isMultiline: true, """ - )(ComInterfaceDispatch.GetInstance((ComInterfaceDispatch*)thisPtr)); - *( - """); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, true); - writer.WriteLine(isMultiline: true, """ - *)result = value; + var value = ({{projected}})(ComInterfaceDispatch.GetInstance((ComInterfaceDispatch*)thisPtr)); + *({{projected}}*)result = value; return 0; } catch (Exception e) From 25a8056e3a56818697477d034287dcc39cc2739a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:36:13 -0700 Subject: [PATCH 025/171] Add WriteTypeNameCallback and migrate string-returning WriteTypeName callers Add a 1:1 callback wrapper for 'TypedefNameWriter.WriteTypeName(IndentedTextWriter, ProjectionEmitContext, TypeSemantics, TypedefNameType, bool)' plus a paired callback-returning factory overload with '' on the writer-taking method. Adding the callback-returning overload at the same signature as the existing string-returning 'WriteTypeName(context, semantics, ...)' helper would conflict on return type, so the string-returning overload is removed and its 11 callers (in AbiClassFactory, AbiInterfaceIDicFactory, AbiMethodBodyFactory.MethodsClass, ClassMembersFactory.WriteInterfaceMembers, MappedInterfaceStubFactory, MetadataAttributeFactory, ObjRefNameGenerator) are migrated to call the new factory and chain '.Format()' to get the standalone string. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiClassFactory.cs | 2 +- .../Factories/AbiInterfaceIDicFactory.cs | 6 ++--- .../AbiMethodBodyFactory.MethodsClass.cs | 2 +- .../Callbacks/WriteTypeNameCallback.cs | 23 +++++++++++++++++++ ...assMembersFactory.WriteInterfaceMembers.cs | 4 ++-- .../Factories/MappedInterfaceStubFactory.cs | 2 +- .../Factories/MetadataAttributeFactory.cs | 4 ++-- .../Helpers/ObjRefNameGenerator.cs | 2 +- .../Helpers/TypedefNameWriter.cs | 19 ++++----------- 9 files changed, 38 insertions(+), 26 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeNameCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index d7048158e..fa9ae06c1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -246,7 +246,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjec } else if (!defaultIfaceIsExclusive && defaultIface is not null) { - string defIfaceTypeName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(defaultIface.ToTypeSignature(false)), TypedefNameType.Projected, false); + string defIfaceTypeName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(defaultIface.ToTypeSignature(false)), TypedefNameType.Projected, false).Format(); writer.WriteLine(isMultiline: true, $$""" if (value is IWindowsRuntimeInterface<{{defIfaceTypeName}}> windowsRuntimeInterface) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index dbb8e6eb5..1d8d160c4 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -129,8 +129,8 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( { if (impl.Interface is TypeSpecification tsMap && tsMap.Signature is GenericInstanceTypeSignature giMap && giMap.TypeArguments.Count == 2) { - string keyText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[0]), TypedefNameType.Projected, true); - string valueText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[1]), TypedefNameType.Projected, true); + string keyText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[0]), TypedefNameType.Projected, true).Format(); + string valueText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[1]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableMapForwarders(writer, context, keyText, valueText); // Mark the inherited IMap`2 / IIterable`1 as visited so they aren't re-emitted. foreach (InterfaceImplementation impl2 in required.Interfaces) @@ -156,7 +156,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( { if (impl.Interface is TypeSpecification tsVec && tsVec.Signature is GenericInstanceTypeSignature giVec && giVec.TypeArguments.Count == 1) { - string elementText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giVec.TypeArguments[0]), TypedefNameType.Projected, true); + string elementText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giVec.TypeArguments[0]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableVectorForwarders(writer, context, elementText); foreach (InterfaceImplementation impl2 in required.Interfaces) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index ffb007419..1b0f94ccc 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -132,7 +132,7 @@ public static unsafe if (isGenericEvent) { - eventSourceProjectedFull = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(evtSig), TypedefNameType.EventSource, true); + eventSourceProjectedFull = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(evtSig), TypedefNameType.EventSource, true).Format(); if (!eventSourceProjectedFull.StartsWith(GlobalPrefix, StringComparison.Ordinal)) { diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeNameCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeNameCallback.cs new file mode 100644 index 000000000..a4d400ec8 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeNameCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteTypeNameCallback( + ProjectionEmitContext context, + TypeSemantics semantics, + TypedefNameType nameType, + bool forceWriteNamespace) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + TypedefNameWriter.WriteTypeName(writer, context, semantics, nameType, forceWriteNamespace); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 695631d75..5df051226 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -237,7 +237,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE if (isGenericInterface && currentInstance is not null) { - string projectedParent = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(currentInstance), TypedefNameType.Projected, true); + string projectedParent = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(currentInstance), TypedefNameType.Projected, true).Format(); genericParentEncoded = IidExpressionGenerator.EscapeTypeNameForIdentifier(projectedParent, stripGlobal: true); genericInteropType = InteropTypeNameWriter.EncodeInteropTypeName(currentInstance, TypedefNameType.StaticAbiClass) + ", WinRT.Interop"; } @@ -479,7 +479,7 @@ static extern } else { - eventSourceType = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(evtSig), TypedefNameType.EventSource, false); + eventSourceType = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(evtSig), TypedefNameType.EventSource, false).Format(); } string eventSourceTypeFull = eventSourceType; diff --git a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs index d44479ef2..7a358f01a 100644 --- a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs @@ -305,7 +305,7 @@ private static void EmitReadOnlyList(IndentedTextWriter writer, ProjectionEmitCo /// private static string WriteTypeNameToString(ProjectionEmitContext context, TypeSemantics arg, TypedefNameType nameType, bool forceQualified) { - string result = TypedefNameWriter.WriteTypeName(context, arg, nameType, forceQualified); + string result = TypedefNameWriter.WriteTypeName(context, arg, nameType, forceQualified).Format(); return result; } diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 49d0599c0..8830a0154 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -344,7 +344,7 @@ public static void AddDefaultInterfaceEntry(ProjectionEmitContext context, TypeD // Build the interface display name via TypeSemantics so generic instantiations // (e.g. IDictionary), TypeRefs and TypeDefs are all handled correctly. - string interfaceName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.GetFromTypeDefOrRef(capturedIface), TypedefNameType.CCW, true); + string interfaceName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.GetFromTypeDefOrRef(capturedIface), TypedefNameType.CCW, true).Format(); _ = entries.TryAdd(className, interfaceName); } @@ -409,7 +409,7 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, } } - string interfaceName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.GetFromTypeDefOrRef(capturedIface), TypedefNameType.CCW, true); + string interfaceName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.GetFromTypeDefOrRef(capturedIface), TypedefNameType.CCW, true).Format(); entries.Add(new KeyValuePair(className, interfaceName)); } } diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 3fb6c4b67..73639961f 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -244,7 +244,7 @@ internal static string BuildIidPropertyNameForGenericInterface(ProjectionEmitCon { TypeSemantics sem = TypeSemanticsFactory.Get(gi); return "IID_" + IidExpressionGenerator.EscapeTypeNameForIdentifier( - TypedefNameWriter.WriteTypeName(context, sem, TypedefNameType.ABI, forceWriteNamespace: true), + TypedefNameWriter.WriteTypeName(context, sem, TypedefNameType.ABI, forceWriteNamespace: true).Format(), stripGlobal: true, stripGlobalABI: true); } diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 156d5fb6f..113c5af61 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -322,22 +322,11 @@ public static void WriteProjectionType(IndentedTextWriter writer, ProjectionEmit WriteTypeName(writer, context, semantics, TypedefNameType.Projected, false); } - /// - /// Convenience overload of - /// that leases an from , - /// emits the type name into it, and returns the resulting string. - /// - /// The active emit context. - /// The semantic representation of the type. - /// The kind of name to emit. - /// When , always prepend the global::-qualified namespace prefix. - /// The emitted type name. - public static string WriteTypeName(ProjectionEmitContext context, TypeSemantics semantics, TypedefNameType nameType = TypedefNameType.Projected, bool forceWriteNamespace = false) + /// + /// A callback that writes the type name to the writer it's appended to. + public static WriteTypeNameCallback WriteTypeName(ProjectionEmitContext context, TypeSemantics semantics, TypedefNameType nameType, bool forceWriteNamespace) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteTypeName(writer, context, semantics, nameType, forceWriteNamespace); - return writer.ToString(); + return new(context, semantics, nameType, forceWriteNamespace); } /// From 89478ad9c2a1c3381b1e3694edcc83530bc95eee Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Fri, 15 May 2026 17:36:59 -0700 Subject: [PATCH 026/171] Refactor EventTableFactory and ComponentFactory inline writes to use callbacks Collapse the 'writer.Write(prefix); TypedefNameWriter.WriteTypeName(writer, ctx, semantics, ...); writer.Write[Line](suffix)' three-call sequences in two emit sites into single interpolated 'writer.WriteLine($"...{name}...")' calls with a hoisted WriteTypeNameCallback local as the interpolation hole: - EventTableFactory.EmitDoAbiAddEvent (non-generic branch) emits ' var __handler = {{abiTypeName}}Marshaller.ConvertToManaged({{handlerRef}});'. - ComponentFactory.WriteFactoryMethodParameters (typed-parameter branch) emits '{{projectedType}} {{paramName}}'. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/WinRT.Projection.Writer/Factories/ComponentFactory.cs | 6 +++--- src/WinRT.Projection.Writer/Factories/EventTableFactory.cs | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 440a28bcf..1ea8871bb 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -6,6 +6,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -307,9 +308,8 @@ private static void WriteFactoryMethodParameters(IndentedTextWriter writer, Proj if (includeTypes) { - TypeSemantics semantics = TypeSemanticsFactory.Get(sig.ParameterTypes[i]); - TypedefNameWriter.WriteTypeName(writer, context, semantics, TypedefNameType.Projected, true); - writer.Write($" {paramName}"); + WriteTypeNameCallback projectedType = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(sig.ParameterTypes[i]), TypedefNameType.Projected, true); + writer.Write($"{projectedType} {paramName}"); } else { diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index f22023b05..2337cd144 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -3,6 +3,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -86,9 +87,8 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit } else { - writer.Write(" var __handler = "); - TypedefNameWriter.WriteTypeName(writer, context, TypeSemanticsFactory.Get(evtTypeSig), TypedefNameType.ABI, false); - writer.WriteLine($"Marshaller.ConvertToManaged({handlerRef});"); + WriteTypeNameCallback abiTypeName = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(evtTypeSig), TypedefNameType.ABI, false); + writer.WriteLine($" var __handler = {abiTypeName}Marshaller.ConvertToManaged({handlerRef});"); } writer.WriteLine(isMultiline: true, $$""" From dd1f0647ac0888b80373fd7b69bd5a4c21ed4f32 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:23:01 -0700 Subject: [PATCH 027/171] Add WriteProjectionReturnTypeCallback + WriteParameterListCallback Add the two highest-leverage method-signature callbacks identified by the multi-agent codebase analysis (M1+M2). They pair naturally because 8 of the 10 affected call sites use both callbacks back-to-back to emit a single method declaration. Migrated sites: - AbiDelegateFactory.cs:174 (Invoke extension) - AbiInterfaceIDicFactory.cs:302, 435 (DIM thunks) - AbiMethodBodyFactory.MethodsClass.cs:65 (Methods class entry) - ClassFactory.cs:358 (static-class method emission) - ClassMembersFactory.WriteInterfaceMembers.cs:315 (UnsafeAccessor extern, return-type only), :328 (generic-iface wrapper), :355 (non-generic wrapper), :383 (overridable explicit-iface impl) - InterfaceFactory.cs:242 (interface member declaration) Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 12 +++---- .../Factories/AbiInterfaceIDicFactory.cs | 13 ++++---- .../AbiMethodBodyFactory.MethodsClass.cs | 12 +++---- .../Callbacks/WriteParameterListCallback.cs | 20 ++++++++++++ .../WriteProjectionReturnTypeCallback.cs | 20 ++++++++++++ .../Factories/ClassFactory.cs | 7 ++--- ...assMembersFactory.WriteInterfaceMembers.cs | 31 +++++++++---------- .../Factories/InterfaceFactory.cs | 7 ++--- .../Factories/MethodFactory.cs | 15 +++++++++ 9 files changed, 92 insertions(+), 45 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterListCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionReturnTypeCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 8caba4b9f..9fb537fee 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -171,13 +172,10 @@ public static unsafe class {{nameStripped}}NativeDelegate { public static unsafe """); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {nameStripped}Invoke(this WindowsRuntimeObjectReference thisReference"); - - writer.WriteIf(sig.Parameters.Count > 0, ", "); - - MethodFactory.WriteParameterList(writer, context, sig); - writer.Write(")"); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + string comma = sig.Parameters.Count > 0 ? ", " : ""; + writer.Write($"{ret} {nameStripped}Invoke(this WindowsRuntimeObjectReference thisReference{comma}{parms})"); // Reuse the interface caller body emitter. Delegate Invoke is at vtable slot 3 // (after QI/AddRef/Release). Functionally equivalent to the truth's diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 1d8d160c4..7c04bd50d 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -299,10 +299,9 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented string mname = method.Name?.Value ?? string.Empty; writer.WriteLine(); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {ccwIfaceName}.{mname}("); - MethodFactory.WriteParameterList(writer, context, sig); - writer.Write($") => (({ccwIfaceName})(WindowsRuntimeObject)this).{mname}("); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.Write($"{ret} {ccwIfaceName}.{mname}({parms}) => (({ccwIfaceName})(WindowsRuntimeObject)this).{mname}("); for (int i = 0; i < sig.Parameters.Count; i++) { writer.WriteIf(i > 0, ", "); @@ -432,9 +431,9 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite writer.WriteLine(); writer.Write("unsafe "); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {ccwIfaceName}.{mname}("); - MethodFactory.WriteParameterList(writer, context, sig); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.Write($"{ret} {ccwIfaceName}.{mname}({parms}"); writer.WriteLine(isMultiline: true, $$""" ) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 1b0f94ccc..80d69cee1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -6,6 +6,7 @@ using System.Globalization; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -62,13 +63,10 @@ internal static void EmitMethodsClassMembersFor(IndentedTextWriter writer, Proje [MethodImpl(MethodImplOptions.NoInlining)] public static unsafe """); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {mname}(WindowsRuntimeObjectReference thisReference"); - - writer.WriteIf(sig.Parameters.Count > 0, ", "); - - MethodFactory.WriteParameterList(writer, context, sig); - writer.Write(")"); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + string comma = sig.Parameters.Count > 0 ? ", " : ""; + writer.Write($"{ret} {mname}(WindowsRuntimeObjectReference thisReference{comma}{parms})"); // Emit the body if we can handle this case. Slot comes from the method's WinMD index. EmitAbiMethodBodyIfSimple(writer, context, sig, methodSlot[method], isNoExcept: method.IsNoExcept()); diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterListCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterListCallback.cs new file mode 100644 index 000000000..98aac65c3 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterListCallback.cs @@ -0,0 +1,20 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteParameterListCallback( + ProjectionEmitContext context, + MethodSignatureInfo sig) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MethodFactory.WriteParameterList(writer, context, sig); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionReturnTypeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionReturnTypeCallback.cs new file mode 100644 index 000000000..2400d1a0b --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionReturnTypeCallback.cs @@ -0,0 +1,20 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteProjectionReturnTypeCallback( + ProjectionEmitContext context, + MethodSignatureInfo sig) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MethodFactory.WriteProjectionReturnType(writer, context, sig); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 28dfaef00..ec96397d6 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -354,10 +354,9 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - writer.Write("public static "); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {mname}("); - MethodFactory.WriteParameterList(writer, context, sig); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.Write($"public static {ret} {mname}({parms}"); if (context.Settings.ReferenceProjection) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 5df051226..f2d8191e0 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -7,6 +7,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -308,12 +309,11 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // Emit UnsafeAccessor static extern + body that dispatches through it. string accessorName = genericParentEncoded + "_" + name; writer.WriteLine(); + WriteProjectionReturnTypeCallback unsafeRet = MethodFactory.WriteProjectionReturnType(context, sig); writer.Write(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{name}}")] - static extern + static extern {{unsafeRet}} {{accessorName}}([UnsafeAccessorType("{{genericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference """); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {accessorName}([UnsafeAccessorType(\"{genericInteropType}\")] object _, WindowsRuntimeObjectReference thisReference"); for (int i = 0; i < sig.Parameters.Count; i++) { writer.Write(", "); @@ -324,10 +324,11 @@ static extern // [global::System.Runtime.Versioning.SupportedOSPlatform("Windows10.0.16299.0")]. writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - writer.Write($"{access}{methodSpecForThis}"); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {name}("); - MethodFactory.WriteParameterList(writer, context, sig); + { + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.Write($"{access}{methodSpecForThis}{ret} {name}({parms}"); + } if (context.Settings.ReferenceProjection) { @@ -351,10 +352,9 @@ static extern writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - writer.Write($"{access}{methodSpecForThis}"); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {name}("); - MethodFactory.WriteParameterList(writer, context, sig); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.Write($"{access}{methodSpecForThis}{ret} {name}({parms}"); if (context.Settings.ReferenceProjection) { @@ -380,12 +380,11 @@ static extern // impl as well (since it shares the same originating interface). writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write(" "); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.Write($"{ret} "); WriteInterfaceTypeNameForCcw(writer, context, originalInterface); - writer.Write($".{name}("); - MethodFactory.WriteParameterList(writer, context, sig); - writer.Write($") => {name}("); + writer.Write($".{name}({parms}) => {name}("); for (int i = 0; i < sig.Parameters.Count; i++) { writer.WriteIf(i > 0, ", "); diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index b714a1a64..a9c6cb595 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -239,10 +239,9 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro // Only emit Windows.Foundation.Metadata attributes that have a projected form // (Overload, DefaultOverload, AttributeUsage, Experimental). WriteMethodCustomAttributes(writer, method); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write($" {method.Name?.Value ?? string.Empty}("); - MethodFactory.WriteParameterList(writer, context, sig); - writer.WriteLine(");"); + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + writer.WriteLine($"{ret} {method.Name?.Value ?? string.Empty}({parms});"); } foreach (PropertyDefinition prop in type.Properties) diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index d9432334c..bb1f19905 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -4,6 +4,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Builders; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -168,6 +169,13 @@ public static void WriteProjectionReturnType(IndentedTextWriter writer, Projecti WriteProjectedSignature(writer, context, rt, false); } + /// + /// A callback that writes the projected return type to the writer it's appended to. + public static WriteProjectionReturnTypeCallback WriteProjectionReturnType(ProjectionEmitContext context, MethodSignatureInfo sig) + { + return new(context, sig); + } + /// /// Writes a comma-separated parameter list. /// @@ -184,6 +192,13 @@ public static void WriteParameterList(IndentedTextWriter writer, ProjectionEmitC } } + /// + /// A callback that writes the parameter list to the writer it's appended to. + public static WriteParameterListCallback WriteParameterList(ProjectionEmitContext context, MethodSignatureInfo sig) + { + return new(context, sig); + } + /// /// Returns the C# literal text for a constant field's value (or empty when no constant). /// From 5daa1dd98f1efb9b27caed38bf334a8aefa4359a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:24:37 -0700 Subject: [PATCH 028/171] Add WriteIidExpressionCallback, drop string overload, migrate callers Mirror the established WriteTypedefName / WriteTypeName migration pattern for ObjRefNameGenerator.WriteIidExpression: add a 1:1 callback wrapper, expose a same-named callback-returning factory overload (with on the writer-taking method), remove the now- conflicting string-returning convenience overload, and migrate its 7 string-callers to call the factory and chain '.Format()'. Also rewrite the 2 inline writer-taking call sites in ClassFactory.cs (the GetActivationFactory return statement at :541-555 and the IsOverridableInterface OR-chain at :732-734) to use the callback as an interpolation hole, collapsing each chunked emission into a single interpolated raw string. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiClassFactory.cs | 4 ++-- .../Factories/AbiDelegateFactory.cs | 8 +++---- .../Callbacks/WriteIidExpressionCallback.cs | 21 +++++++++++++++++++ .../Factories/ClassFactory.cs | 13 +++++------- .../ConstructorFactory.FactoryCallbacks.cs | 2 +- .../Helpers/ObjRefNameGenerator.cs | 18 +++++----------- 6 files changed, 38 insertions(+), 28 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidExpressionCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index fa9ae06c1..746897f05 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -77,7 +77,7 @@ internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, Pr else { defaultIfaceIid = defaultIface is not null - ? ObjRefNameGenerator.WriteIidExpression(context, defaultIface) + ? ObjRefNameGenerator.WriteIidExpression(context, defaultIface).Format() : "default(global::System.Guid)"; } @@ -213,7 +213,7 @@ internal static void WriteClassMarshallerStub(IndentedTextWriter writer, Project // Get the IID expression for the default interface (used by CreateObject). ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); string defaultIfaceIid = defaultIface is not null - ? ObjRefNameGenerator.WriteIidExpression(context, defaultIface) + ? ObjRefNameGenerator.WriteIidExpression(context, defaultIface).Format() : "default(global::System.Guid)"; // Determine the marshalingType expression from the class's [MarshalingBehaviorAttribute]. diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 9fb537fee..df13248ee 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -69,7 +69,7 @@ private static void WriteDelegateImpl(IndentedTextWriter writer, ProjectionEmitC MethodSignatureInfo sig = new(invoke); string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); - string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); + string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); writer.WriteLine(); writer.Write(isMultiline: true, $$""" @@ -195,7 +195,7 @@ private static void WriteDelegateInterfaceEntriesImpl(IndentedTextWriter writer, string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); - string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); + string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(); @@ -347,7 +347,7 @@ private static void WriteDelegateMarshallerOnly(IndentedTextWriter writer, Proje string nameStripped = IdentifierEscaping.StripBackticks(name); string typeNs = type.Namespace?.Value ?? string.Empty; string fullProjected = $"global::{typeNs}.{nameStripped}"; - string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); + string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -381,7 +381,7 @@ private static void WriteDelegateComWrappersCallback(IndentedTextWriter writer, string nameStripped = IdentifierEscaping.StripBackticks(name); string typeNs = type.Namespace?.Value ?? string.Empty; string fullProjected = $"global::{typeNs}.{nameStripped}"; - string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type); + string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidExpressionCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidExpressionCallback.cs new file mode 100644 index 000000000..d3f1c16c8 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidExpressionCallback.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteIidExpressionCallback( + ProjectionEmitContext context, + ITypeDefOrRef ifaceType) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + ObjRefNameGenerator.WriteIidExpression(writer, context, ifaceType); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index ec96397d6..400adee06 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -537,7 +537,8 @@ private static WindowsRuntimeObjectReference {{objRefName}} """); return; } - writer.Write(isMultiline: true, $$""" + WriteIidExpressionCallback iid = ObjRefNameGenerator.WriteIidExpression(context, staticIface); + writer.WriteLine(isMultiline: true, $$""" get { var __{{objRefName}} = field; @@ -545,11 +546,7 @@ private static WindowsRuntimeObjectReference {{objRefName}} { return __{{objRefName}}; } - return field = WindowsRuntimeObjectReference.GetActivationFactory("{{runtimeClassFullName}}", - """); - ObjRefNameGenerator.WriteIidExpression(writer, context, staticIface); - writer.WriteLine(isMultiline: true, """ - ); + return field = WindowsRuntimeObjectReference.GetActivationFactory("{{runtimeClassFullName}}", {{iid}}); } } """); @@ -729,8 +726,8 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont writer.WriteIf(!firstClause, " || "); firstClause = false; - ObjRefNameGenerator.WriteIidExpression(writer, context, implRef); - writer.Write(" == iid"); + WriteIidExpressionCallback iid = ObjRefNameGenerator.WriteIidExpression(context, implRef); + writer.Write($"{iid} == iid"); } // base call when type has a non-object base class diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index abdd093ec..57aae2910 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -676,7 +676,7 @@ private static string GetDefaultInterfaceIid(ProjectionEmitContext context, Type return "default(global::System.Guid)"; } - string result = ObjRefNameGenerator.WriteIidExpression(context, defaultIface); + string result = ObjRefNameGenerator.WriteIidExpression(context, defaultIface).Format(); return result; } } diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 73639961f..6ccf36840 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -5,6 +5,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Factories; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Writers; @@ -220,20 +221,11 @@ public static void WriteIidExpression(IndentedTextWriter writer, ProjectionEmitC } } - /// - /// Convenience overload of - /// that leases an from , - /// emits the IID expression into it, and returns the resulting string. - /// - /// The active emit context. - /// The interface type whose IID expression is emitted. - /// The emitted IID expression. - public static string WriteIidExpression(ProjectionEmitContext context, ITypeDefOrRef ifaceType) + /// + /// A callback that writes the IID expression to the writer it's appended to. + public static WriteIidExpressionCallback WriteIidExpression(ProjectionEmitContext context, ITypeDefOrRef ifaceType) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteIidExpression(writer, context, ifaceType); - return writer.ToString(); + return new(context, ifaceType); } /// From 33c434ba574a4e62a572e44f0a3b7ce67376c3e1 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:26:14 -0700 Subject: [PATCH 029/171] Add WriteIidReferenceExpressionCallback, drop string overload, migrate callers Same pattern as M3 (WriteIidExpressionCallback) but for the IReference-flavored IID variant on ObjRefNameGenerator. Add the 1:1 callback wrapper, expose the same-named factory overload (with ), remove the string-returning convenience overload, and update the 4 callers in AbiDelegateFactory.cs:199,413 and StructEnumMarshallerFactory.cs:257,301 to declare the local as WriteIidReferenceExpressionCallback. The local is consumed only via interpolated raw strings on the writer at all 4 sites, so no template changes are needed. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 4 ++-- .../WriteIidReferenceExpressionCallback.cs | 18 ++++++++++++++++++ .../Factories/StructEnumMarshallerFactory.cs | 4 ++-- .../Helpers/ObjRefNameGenerator.cs | 16 ++++------------ 4 files changed, 26 insertions(+), 16 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceExpressionCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index df13248ee..8e1913075 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -196,7 +196,7 @@ private static void WriteDelegateInterfaceEntriesImpl(IndentedTextWriter writer, string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); - string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); + WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -410,7 +410,7 @@ private static void WriteDelegateComWrappersMarshallerAttribute(IndentedTextWrit { string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); - string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); + WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceExpressionCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceExpressionCallback.cs new file mode 100644 index 000000000..57a0b5e62 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceExpressionCallback.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteIidReferenceExpressionCallback(TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + ObjRefNameGenerator.WriteIidReferenceExpression(writer, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 5a669a91c..a7cb97bd0 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -254,7 +254,7 @@ public static void Dispose({{abi}} value) // type still routes through this marshaller (it just lacks per-field // ConvertToUnmanaged/ConvertToManaged because the field layout doesn't match). string boxFlags = (isEnum || almostBlittable || isComplexStruct) && hasReferenceFields ? "TrackerSupport" : "None"; - string boxIidRef = ObjRefNameGenerator.WriteIidReferenceExpression(type); + WriteIidReferenceExpressionCallback boxIidRef = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(isMultiline: true, $$""" public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? value) @@ -298,7 +298,7 @@ public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? v // unboxing to the ABI struct. if (isEnum || almostBlittable || isComplexStruct) { - string iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); + WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); // InterfaceEntriesImpl writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 6ccf36840..8bcd47812 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -299,19 +299,11 @@ public static void WriteIidReferenceExpression(IndentedTextWriter writer, TypeDe writer.Write($"global::ABI.InterfaceIIDs.IID_{id}Reference"); } - /// - /// Convenience overload of - /// that leases an from , - /// emits the IID reference expression into it, and returns the resulting string. - /// - /// The value type whose IReference<T> IID expression is emitted. - /// The emitted IID reference expression. - public static string WriteIidReferenceExpression(TypeDefinition type) + /// + /// A callback that writes the IID reference expression to the writer it's appended to. + public static WriteIidReferenceExpressionCallback WriteIidReferenceExpression(TypeDefinition type) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteIidReferenceExpression(writer, type); - return writer.ToString(); + return new(type); } /// From e79317676ffad1eae2aa00307964604a69d83e16 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:28:01 -0700 Subject: [PATCH 030/171] Add WriteEventTypeCallback (both overloads) and migrate callers Add a single WriteEventTypeCallback struct that carries the nullable 'currentInstance' parameter (the only difference between the two writer-taking overloads, since the 3-arg overload simply delegates to the 4-arg one with null). Expose two same-named factory overloads on TypedefNameWriter (with on the corresponding writer-taking methods), one per shape. Remove the conflicting string-returning 'WriteEventType(context, evt)' overload and migrate its single caller (EventTableFactory.cs:29) to declare a WriteEventTypeCallback local that gets interpolated directly into the surrounding multiline raw string. Refactor the 5 inline writer-taking sites in AbiInterfaceIDicFactory.cs:351,515, ClassFactory.cs:387, ClassMembersFactory.WriteInterfaceMembers.cs:568, InterfaceFactory.cs:269 to use the callback as a {{eventType}} interpolation hole, collapsing each chunked emission into a single interpolated raw string per event declaration. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 10 ++++---- .../Callbacks/WriteEventTypeCallback.cs | 23 ++++++++++++++++++ .../Factories/ClassFactory.cs | 5 ++-- ...assMembersFactory.WriteInterfaceMembers.cs | 5 ++-- .../Factories/EventTableFactory.cs | 2 +- .../Factories/InterfaceFactory.cs | 5 ++-- .../Helpers/TypedefNameWriter.cs | 24 +++++++++---------- 7 files changed, 45 insertions(+), 29 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteEventTypeCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 7c04bd50d..02c4851b7 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -347,10 +347,9 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented { string evtName = evt.Name?.Value ?? string.Empty; writer.WriteLine(); - writer.Write("event "); - TypedefNameWriter.WriteEventType(writer, context, evt); + WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(isMultiline: true, $$""" - {{ccwIfaceName}}.{{evtName}} + event {{eventType}} {{ccwIfaceName}}.{{evtName}} { add => (({{ccwIfaceName}})(WindowsRuntimeObject)this).{{evtName}} += value; remove => (({{ccwIfaceName}})(WindowsRuntimeObject)this).{{evtName}} -= value; @@ -511,10 +510,9 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite { string evtName = evt.Name?.Value ?? string.Empty; writer.WriteLine(); - writer.Write("event "); - TypedefNameWriter.WriteEventType(writer, context, evt); + WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(isMultiline: true, $$""" - {{ccwIfaceName}}.{{evtName}} + event {{eventType}} {{ccwIfaceName}}.{{evtName}} { add { diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteEventTypeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteEventTypeCallback.cs new file mode 100644 index 000000000..053f22b6d --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteEventTypeCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteEventTypeCallback( + ProjectionEmitContext context, + EventDefinition evt, + GenericInstanceTypeSignature? currentInstance) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + TypedefNameWriter.WriteEventType(writer, context, evt, currentInstance); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 400adee06..cfb520419 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -383,10 +383,9 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - writer.Write("public static event "); - TypedefNameWriter.WriteEventType(writer, context, evt); + WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(isMultiline: true, $$""" - {{evtName}} + public static event {{eventType}} {{evtName}} { """); if (context.Settings.ReferenceProjection) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index f2d8191e0..c60124d3b 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -564,10 +564,9 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // [global::System.Runtime.Versioning.SupportedOSPlatform("Windows10.0.16299.0")]. writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - writer.Write($"{access}{methodSpec}event "); - TypedefNameWriter.WriteEventType(writer, context, evt, currentInstance); + WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt, currentInstance); writer.WriteLine(isMultiline: true, $$""" - {{name}} + {{access}}{{methodSpec}}event {{eventType}} {{name}} { """); if (context.Settings.ReferenceProjection) diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index 2337cd144..626e9d22c 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -26,7 +26,7 @@ internal static class EventTableFactory internal static void EmitEventTableField(IndentedTextWriter writer, ProjectionEmitContext context, EventDefinition evt, string ifaceFullName) { string evName = evt.Name?.Value ?? "Event"; - string evtType = TypedefNameWriter.WriteEventType(context, evt); + WriteEventTypeCallback evtType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index a9c6cb595..93f61a10b 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -265,9 +265,8 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro foreach (EventDefinition evt in type.Events) { - writer.Write("event "); - TypedefNameWriter.WriteEventType(writer, context, evt); - writer.WriteLine($" {evt.Name?.Value ?? string.Empty};"); + WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); + writer.WriteLine($"event {eventType} {evt.Name?.Value ?? string.Empty};"); } } diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 113c5af61..1afc53e3e 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -353,20 +353,18 @@ public static string WriteProjectionType(ProjectionEmitContext context, TypeSema public static void WriteEventType(IndentedTextWriter writer, ProjectionEmitContext context, EventDefinition evt) => WriteEventType(writer, context, evt, null); - /// - /// Convenience overload of - /// that leases an from , - /// emits the event handler type into it, and returns the resulting string. - /// - /// The active emit context. - /// The event definition whose handler type is emitted. - /// The emitted event handler type name. - public static string WriteEventType(ProjectionEmitContext context, EventDefinition evt) + /// + /// A callback that writes the event handler type to the writer it's appended to. + public static WriteEventTypeCallback WriteEventType(ProjectionEmitContext context, EventDefinition evt) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteEventType(writer, context, evt, null); - return writer.ToString(); + return new(context, evt, null); + } + + /// + /// A callback that writes the event handler type to the writer it's appended to. + public static WriteEventTypeCallback WriteEventType(ProjectionEmitContext context, EventDefinition evt, GenericInstanceTypeSignature? currentInstance) + { + return new(context, evt, currentInstance); } /// From b5c6bc3b2b942fc8982cc9458020a569b4b6ef9f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:32:31 -0700 Subject: [PATCH 031/171] Add WriteAbiTypeCallback + WriteEscapedIdentifierCallback paired Add two callbacks together because both apply inside AbiInterfaceFactory.WriteAbiParameterTypesPointer (the densest chunked-emission method in the project, 125+ lines pre-refactor). Add 1:1 wrappers, factory overloads on AbiTypeWriter and IdentifierEscaping (each with ), and rewrite the helper to use the two callbacks plus per-branch single 'writer.Write(...)' calls. Also migrate two smaller call sites that use the same helpers inline: - ConstructorFactory.FactoryCallbacks.cs:490 (factory-callback ABI type list) - ProjectionFileBuilder.cs:235, :247, :255 (positional-ctor field and assignment emission) Note: each branch in the rewritten WriteAbiParameterTypesPointer uses an explicit 'if (includeParamNames) { writer.Write($"...{name}") } else { writer.Write($"...") }' pattern. A conditional ternary 'writer.Write(cond ? $"A{cb}" : $"B{cb}")' would silently force both branches to evaluate as 'string' (calling 'ToString()' on the callback), bypassing the interpolated-string handler and emitting the callback's fully-qualified type name into the output. Always use explicit if/else so each branch gets its own handler-dispatching interpolated 'writer.Write($"...")' call. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 14 ++-- .../Factories/AbiInterfaceFactory.cs | 65 +++++++++---------- .../Callbacks/WriteAbiTypeCallback.cs | 21 ++++++ .../WriteEscapedIdentifierCallback.cs | 17 +++++ .../ConstructorFactory.FactoryCallbacks.cs | 5 +- .../Helpers/AbiTypeWriter.cs | 8 +++ .../Helpers/IdentifierEscaping.cs | 8 +++ 7 files changed, 93 insertions(+), 45 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiTypeCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteEscapedIdentifierCallback.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 9c9c7ad00..20f918ceb 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -8,6 +8,7 @@ using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Errors; using WindowsRuntime.ProjectionWriter.Factories; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -232,8 +233,8 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext { writer.WriteIf(i > 0, ", "); - writer.Write($"{fields[i].TypeStr} "); - IdentifierEscaping.WriteEscapedIdentifier(writer, fields[i].ParamName); + WriteEscapedIdentifierCallback name = IdentifierEscaping.WriteEscapedIdentifier(fields[i].ParamName); + writer.Write($"{fields[i].TypeStr} {name}"); } writer.WriteLine(")"); @@ -243,17 +244,14 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext { // When the param name matches the field name (i.e. ToCamelCase couldn't change casing), // qualify with this. to disambiguate. + WriteEscapedIdentifierCallback paramRef = IdentifierEscaping.WriteEscapedIdentifier(paramName); if (name == paramName) { - writer.Write($"this.{name} = "); - IdentifierEscaping.WriteEscapedIdentifier(writer, paramName); - writer.Write("; "); + writer.Write($"this.{name} = {paramRef}; "); } else { - writer.Write($"{name} = "); - IdentifierEscaping.WriteEscapedIdentifier(writer, paramName); - writer.Write("; "); + writer.Write($"{name} = {paramRef}; "); } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 422f63200..5403460af 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -71,14 +71,15 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj writer.Write(", "); ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + string paramName = p.Parameter.Name ?? "param"; + WriteEscapedIdentifierCallback name = IdentifierEscaping.WriteEscapedIdentifier(paramName); if (p.Type is SzArrayTypeSignature) { // length pointer + value pointer. if (includeParamNames) { - writer.Write($"uint __{p.Parameter.Name ?? "param"}Size, void* "); - IdentifierEscaping.WriteEscapedIdentifier(writer, p.Parameter.Name ?? "param"); + writer.Write($"uint __{paramName}Size, void* {name}"); } else { @@ -91,60 +92,55 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj if (br.BaseType is SzArrayTypeSignature brSz && cat == ParameterCategory.ReceiveArray) { bool isRefElemBr = brSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(brSz.BaseType) || brSz.BaseType.IsObject() || brSz.BaseType.IsGenericInstance(); + WriteAbiTypeCallback elemAbi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(brSz.BaseType)); if (includeParamNames) { - writer.Write($"uint* __{p.Parameter.Name ?? "param"}Size, "); - if (isRefElemBr) { - writer.Write("void*** "); + writer.Write($"uint* __{paramName}Size, void*** {name}"); } else { - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(brSz.BaseType)); - writer.Write("** "); + writer.Write($"uint* __{paramName}Size, {elemAbi}** {name}"); } - - IdentifierEscaping.WriteEscapedIdentifier(writer, p.Parameter.Name ?? "param"); } else { - writer.Write("uint*, "); - if (isRefElemBr) { - writer.Write("void***"); + writer.Write("uint*, void***"); } else { - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(brSz.BaseType)); - writer.Write("**"); + writer.Write($"uint*, {elemAbi}**"); } } } else { - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(br.BaseType)); - writer.Write("*"); - + WriteAbiTypeCallback abi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(br.BaseType)); if (includeParamNames) { - writer.Write(" "); - IdentifierEscaping.WriteEscapedIdentifier(writer, p.Parameter.Name ?? "param"); + writer.Write($"{abi}* {name}"); + } + else + { + writer.Write($"{abi}*"); } } } else { - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(p.Type)); - - writer.WriteIf(cat is ParameterCategory.Out or ParameterCategory.Ref, "*"); - + WriteAbiTypeCallback abi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(p.Type)); + string ptr = cat is ParameterCategory.Out or ParameterCategory.Ref ? "*" : ""; if (includeParamNames) { - writer.Write(" "); - IdentifierEscaping.WriteEscapedIdentifier(writer, p.Parameter.Name ?? "param"); + writer.Write($"{abi}{ptr} {name}"); + } + else + { + writer.Write($"{abi}{ptr}"); } } } @@ -158,27 +154,26 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj // Special handling for SzArray return types: WinRT projects them as a (uint*, T**) pair. if (sig.ReturnType is SzArrayTypeSignature retSz) { + WriteAbiTypeCallback elemAbi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(retSz.BaseType)); if (includeParamNames) { - writer.Write($"uint* {retSizeName}, "); - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(retSz.BaseType)); - writer.Write($"** {retName}"); + writer.Write($"uint* {retSizeName}, {elemAbi}** {retName}"); } else { - writer.Write("uint*, "); - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(retSz.BaseType)); - writer.Write("**"); + writer.Write($"uint*, {elemAbi}**"); } } else { - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(sig.ReturnType)); - writer.Write("*"); - + WriteAbiTypeCallback retAbi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(sig.ReturnType)); if (includeParamNames) { - writer.Write($" {retName}"); + writer.Write($"{retAbi}* {retName}"); + } + else + { + writer.Write($"{retAbi}*"); } } } diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiTypeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiTypeCallback.cs new file mode 100644 index 000000000..56ed8d5b0 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiTypeCallback.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteAbiTypeCallback( + ProjectionEmitContext context, + TypeSemantics semantics) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + AbiTypeWriter.WriteAbiType(writer, context, semantics); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteEscapedIdentifierCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteEscapedIdentifierCallback.cs new file mode 100644 index 000000000..b26ad786e --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteEscapedIdentifierCallback.cs @@ -0,0 +1,17 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteEscapedIdentifierCallback(string identifier) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + IdentifierEscaping.WriteEscapedIdentifier(writer, identifier); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 57aae2910..c58297fdf 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -5,6 +5,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -487,8 +488,8 @@ public override unsafe void Invoke( continue; } - AbiTypeWriter.WriteAbiType(writer, context, TypeSemanticsFactory.Get(p.Type)); - writer.Write(", "); + WriteAbiTypeCallback abi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(p.Type)); + writer.Write($"{abi}, "); } if (isComposable) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index ea7950afc..700b81d03 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -5,6 +5,7 @@ using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -198,6 +199,13 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext } } + /// + /// A callback that writes the ABI type to the writer it's appended to. + public static WriteAbiTypeCallback WriteAbiType(ProjectionEmitContext context, TypeSemantics semantics) + { + return new(context, semantics); + } + /// /// Returns the ABI C# type name for a fundamental type (e.g. "bool" -> "byte", "char" -> "ushort"). /// diff --git a/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs b/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs index b4b0d466a..025c102a5 100644 --- a/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs +++ b/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -35,6 +36,13 @@ public static void WriteEscapedIdentifier(IndentedTextWriter writer, string iden writer.Write(identifier); } + /// + /// A callback that writes the escaped identifier to the writer it's appended to. + public static WriteEscapedIdentifierCallback WriteEscapedIdentifier(string identifier) + { + return new(identifier); + } + /// /// Returns the camel-case form of : if the first character is an /// upper-case ASCII letter, it is lowered; otherwise is returned From bea62f85c5dfeffa655807bd17ec915f4451dc43 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:51:14 -0700 Subject: [PATCH 032/171] Add WriteProjectedSignatureCallback, drop string overload, migrate callers Largest single migration in the callback series: 17 callers across 7 files. Add a 1:1 callback wrapper, expose the callback-returning factory overload on MethodFactory (with ), and remove the conflicting string-returning convenience overload. Selective per-caller migration following the merged report's policy ("immediate-emission callers switch to callback; stateful callers that consume the string outside of writer interpolation use .Format()"): - 14 sites (AbiMethodBodyFactory.DoAbi.cs:80,110,182,187,192,244,394; AbiMethodBodyFactory.RcwCaller.cs:285,1167,1307; ConstructorFactory.FactoryCallbacks.cs:177; EventTableFactory.cs:81; ReferenceImplFactory.cs:88,115) immediately interpolate the result into writer.WriteLine($"..."); locals switched from 'string' to 'WriteProjectedSignatureCallback'. - 3 sites (InterfaceFactory.WritePropType:222 and AbiTypeHelpers.AbiTypeNames:28 each return the string from a helper method that surfaces it via non-writer APIs; AbiMethodBodyFactory.RcwCaller.cs:1352 uses the result both in a string equality check and in interpolation) keep 'string' locals and chain '.Format()' to materialise it. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 15 ++++++------- .../AbiMethodBodyFactory.RcwCaller.cs | 9 ++++---- .../WriteProjectedSignatureCallback.cs | 21 +++++++++++++++++++ .../ConstructorFactory.FactoryCallbacks.cs | 2 +- .../Factories/EventTableFactory.cs | 2 +- .../Factories/InterfaceFactory.cs | 2 +- .../Factories/MethodFactory.cs | 18 ++++------------ .../Factories/ReferenceImplFactory.cs | 4 ++-- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 +- 9 files changed, 44 insertions(+), 31 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectedSignatureCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index f2e0153b3..ad4992d42 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -5,6 +5,7 @@ using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Errors; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -77,7 +78,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (returnIsGenericInstance && !(rt is not null && rt.IsNullableT())) { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(rt!, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt!, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt!, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); @@ -107,7 +108,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); @@ -179,17 +180,17 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else if (returnIsRefType) { - string projected = MethodFactory.WriteProjectedSignature(context, rt, false); + WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine($"{projected} {retLocalName} = default;"); } else if (returnIsReceiveArrayDoAbi) { - string projected = MethodFactory.WriteProjectedSignature(context, rt, false); + WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine($"{projected} {retLocalName} = default;"); } else { - string projected = MethodFactory.WriteProjectedSignature(context, rt, false); + WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine($"{projected} {retLocalName} = default;"); } } @@ -241,7 +242,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Use the projected (non-ABI) type for the local variable. // Strip ByRef and CustomModifier wrappers to get the underlying base type. TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - string projected = MethodFactory.WriteProjectedSignature(context, underlying, false); + WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, underlying, false); writer.WriteLine($"{projected} __{raw} = default;"); } @@ -391,7 +392,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string rawName = p.Parameter.Name ?? "param"; string callName = CSharpKeywords.IsKeyword(rawName) ? "@" + rawName : rawName; string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] static extern {{projectedTypeName}} ConvertToManaged_arg_{{rawName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index d2c85913f..9636de212 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -7,6 +7,7 @@ using System.Text; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -282,7 +283,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); @@ -1164,7 +1165,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (uOut.IsGenericInstance()) { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{projectedTypeName}} ConvertToManaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); @@ -1304,7 +1305,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else if (rt.IsGenericInstance()) { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(rt, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{projectedTypeName}} ConvertToManaged_retval([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); @@ -1349,7 +1350,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else { writer.Write($"{callIndent}return "); - string projected = MethodFactory.WriteProjectedSignature(context, rt!, false); + string projected = MethodFactory.WriteProjectedSignature(context, rt!, false).Format(); string abiType = AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, rt!); if (projected == abiType) diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectedSignatureCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectedSignatureCallback.cs new file mode 100644 index 000000000..27e42b950 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectedSignatureCallback.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteProjectedSignatureCallback( + ProjectionEmitContext context, + TypeSignature typeSig, + bool isParameter) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MethodFactory.WriteProjectedSignature(writer, context, typeSig, isParameter); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index c58297fdf..6484aeb37 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -174,7 +174,7 @@ public override unsafe void Invoke( } string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index 626e9d22c..3c87a20f0 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -78,7 +78,7 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit if (isGeneric) { string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(evtTypeSig, TypedefNameType.ABI) + ", WinRT.Interop"; - string projectedTypeName = MethodFactory.WriteProjectedSignature(context, evtTypeSig, false); + WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, evtTypeSig, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] static extern {{projectedTypeName}} ConvertToManaged([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 93f61a10b..454704306 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -219,7 +219,7 @@ public static string WritePropType(ProjectionEmitContext context, PropertyDefini typeSig = typeSig.InstantiateGenericTypes(genericContext.Value); } - string result = MethodFactory.WriteProjectedSignature(context, typeSig, isSetProperty); + string result = MethodFactory.WriteProjectedSignature(context, typeSig, isSetProperty).Format(); return result; } diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index bb1f19905..b93a5309f 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -56,21 +56,11 @@ public static void WriteProjectedSignature(IndentedTextWriter writer, Projection TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(typeSig)); } - /// - /// Convenience overload of - /// that leases an from , - /// emits the projected signature into it, and returns the resulting string. - /// - /// The active emit context. - /// The signature to project. - /// When , projects SZ-arrays as (parameter convention) instead of T[]. - /// The projected signature. - public static string WriteProjectedSignature(ProjectionEmitContext context, TypeSignature typeSig, bool isParameter) + /// + /// A callback that writes the projected signature to the writer it's appended to. + public static WriteProjectedSignatureCallback WriteProjectedSignature(ProjectionEmitContext context, TypeSignature typeSig, bool isParameter) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteProjectedSignature(writer, context, typeSig, isParameter); - return writer.ToString(); + return new(context, typeSig, isParameter); } /// diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 2a5ea0e7c..d29efb86b 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -85,7 +85,7 @@ public static int get_Value(void* thisPtr, void* result) { // Non-blittable struct: marshal via Marshaller.ConvertToUnmanaged then write the // (ABI) struct value into the result pointer. - string projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); + WriteProjectedSignatureCallback projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); string abiName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, type.ToTypeSignature()); writer.WriteLine(isMultiline: true, $$""" public static int get_Value(void* thisPtr, void* result) @@ -112,7 +112,7 @@ public static int get_Value(void* thisPtr, void* result) else if (TypeCategorization.GetCategory(type) is TypeCategory.Class or TypeCategory.Delegate) { // Non-blittable runtime class / delegate: marshal via Marshaller and detach. - string projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); + WriteProjectedSignatureCallback projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); writer.WriteLine(isMultiline: true, $$""" public static int get_Value(void* thisPtr, void* result) { diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 05d08f91b..b0997b6f7 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -25,7 +25,7 @@ internal static string GetBlittableStructAbiType(IndentedTextWriter writer, Proj return GetMappedAbiTypeName(sig); } - string result = MethodFactory.WriteProjectedSignature(context, sig, false); + string result = MethodFactory.WriteProjectedSignature(context, sig, false).Format(); return result; } From 9466c261e287f365e37152137022ea86498ec754 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:54:33 -0700 Subject: [PATCH 033/171] Add WriteProjectionTypeCallback, drop string overload, migrate callers Add a 1:1 callback wrapper, expose the same-named factory overload on TypedefNameWriter (with ), and remove the conflicting string-returning convenience overload. Migrate string callers selectively: - 11 sites switch the 'string elementProjected'/'string fieldType' local to WriteProjectionTypeCallback and remove the intermediate string allocation: AbiMethodBodyFactory.DoAbi.cs (7 sites), AbiMethodBodyFactory.RcwCaller.cs (4 sites), ConstructorFactory.FactoryCallbacks.cs (1 site), ProjectionFileBuilder.cs:412 (1 site). - 1 site (ProjectionFileBuilder.cs:198 'fieldType') stores the result in a List<(string TypeStr, ...)> tuple consumed elsewhere; keep as string with '.Format()'. Also refactor the 4 inline writer-taking call sites in MethodFactory.cs (WriteProjectedSignature SZ array branches and WriteProjectionParameterType PassArray/FillArray/ReceiveArray branches) plus 2 in ConstructorFactory.FactoryCallbacks.cs:138,144 to use the callback as a {{elem}} interpolation hole inside a single writer.Write($"...") call. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 7 +++-- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 14 +++++----- .../AbiMethodBodyFactory.RcwCaller.cs | 8 +++--- .../Callbacks/WriteProjectionTypeCallback.cs | 21 +++++++++++++++ .../ConstructorFactory.FactoryCallbacks.cs | 12 ++++----- .../Factories/MethodFactory.cs | 26 +++++++++---------- .../Helpers/TypedefNameWriter.cs | 17 +++--------- 7 files changed, 57 insertions(+), 48 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionTypeCallback.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 20f918ceb..c8aae02e9 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -195,7 +195,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext } TypeSemantics semantics = TypeSemanticsFactory.Get(field.Signature.FieldType); - string fieldType = TypedefNameWriter.WriteProjectionType(context, semantics); + string fieldType = TypedefNameWriter.WriteProjectionType(context, semantics).Format(); string fieldName = field.Name?.Value ?? string.Empty; string paramName = IdentifierEscaping.ToCamelCase(fieldName); bool isInterface = false; @@ -408,9 +408,8 @@ public static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitConte continue; } - writer.Write("public "); - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(field.Signature.FieldType)); - writer.WriteLine($" {field.Name?.Value ?? string.Empty};"); + WriteProjectionTypeCallback fieldType = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(field.Signature.FieldType)); + writer.WriteLine($"public {fieldType} {field.Name?.Value ?? string.Empty};"); } } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index ad4992d42..5f66a979e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -131,7 +131,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(sza.BaseType, TypedefNameType.Projected); _ = elementInteropArg; @@ -152,7 +152,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (returnIsReceiveArrayDoAbi && rt is SzArrayTypeSignature retSzHoist) { - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSzHoist.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSzHoist.BaseType)); string elementAbi = retSzHoist.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSzHoist.BaseType) || retSzHoist.BaseType.IsObject() ? "void*" : context.AbiTypeShapeResolver.IsComplexStruct(retSzHoist.BaseType) @@ -262,7 +262,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); writer.WriteLine(isMultiline: true, $$""" *{{ptr}} = default; *__{{raw}}Size = default; @@ -291,7 +291,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittablePrimitive(sz.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(sz.BaseType); if (isBlittableElem) @@ -342,7 +342,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); _ = elementInteropArg; @@ -633,7 +633,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szFA.BaseType, TypedefNameType.Projected); _ = elementInteropArg; @@ -820,7 +820,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" if (__{{raw}}_arrayFromPool is not null) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 9636de212..a88e28668 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -902,7 +902,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); _ = elementInteropArg; @@ -1102,7 +1102,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szFA.BaseType, TypedefNameType.Projected); _ = elementInteropArg; @@ -1236,7 +1236,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); // Element ABI type: void* for ref types (string/runtime class/object); ABI struct // type for complex structs (e.g. authored BasicStruct); blittable struct ABI for // blittable structs; primitive ABI otherwise. @@ -1263,7 +1263,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (returnIsReceiveArray) { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSz.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSz.BaseType)); string elementAbi = retSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSz.BaseType) || retSz.BaseType.IsObject() ? "void*" : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionTypeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionTypeCallback.cs new file mode 100644 index 000000000..4d8f587f9 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionTypeCallback.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteProjectionTypeCallback( + ProjectionEmitContext context, + TypeSemantics semantics) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + TypedefNameWriter.WriteProjectionType(writer, context, semantics); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 6484aeb37..90090e40a 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -134,15 +134,13 @@ public override unsafe void Invoke( // For array params, the bind type is ReadOnlySpan / Span (not the SzArray). if (cat == ParameterCategory.PassArray) { - writer.Write("ReadOnlySpan<"); - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); - writer.Write(">"); + WriteProjectionTypeCallback elem = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); + writer.Write($"ReadOnlySpan<{elem}>"); } else if (cat == ParameterCategory.FillArray) { - writer.Write("Span<"); - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); - writer.Write(">"); + WriteProjectionTypeCallback elem = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); + writer.Write($"Span<{elem}>"); } else { @@ -465,7 +463,7 @@ public override unsafe void Invoke( } else { - string elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); + WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); _ = elementInteropArg; writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index b93a5309f..f8ff6306e 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -32,16 +32,14 @@ public static void WriteProjectedSignature(IndentedTextWriter writer, Projection { // SZ arrays project as ReadOnlySpan (matches the property setter parameter // convention; pass_array semantics). + WriteProjectionTypeCallback elem = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); if (isParameter) { - writer.Write("ReadOnlySpan<"); - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(sz.BaseType)); - writer.Write(">"); + writer.Write($"ReadOnlySpan<{elem}>"); } else { - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(sz.BaseType)); - writer.Write("[]"); + writer.Write($"{elem}[]"); } return; @@ -83,14 +81,16 @@ public static void WriteProjectionParameterType(IndentedTextWriter writer, Proje WriteProjectedSignature(writer, context, p.Type, true); break; case ParameterCategory.PassArray: - writer.Write("ReadOnlySpan<"); - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); - writer.Write(">"); + { + WriteProjectionTypeCallback elem = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); + writer.Write($"ReadOnlySpan<{elem}>"); + } break; case ParameterCategory.FillArray: - writer.Write("Span<"); - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); - writer.Write(">"); + { + WriteProjectionTypeCallback elem = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(((SzArrayTypeSignature)p.Type).BaseType)); + writer.Write($"Span<{elem}>"); + } break; case ParameterCategory.ReceiveArray: writer.Write("out "); @@ -99,8 +99,8 @@ public static void WriteProjectionParameterType(IndentedTextWriter writer, Proje if (sz is not null) { - TypedefNameWriter.WriteProjectionType(writer, context, TypeSemanticsFactory.Get(sz.BaseType)); - writer.Write("[]"); + WriteProjectionTypeCallback elem = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); + writer.Write($"{elem}[]"); } else { diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 1afc53e3e..e404c2ab0 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -329,20 +329,11 @@ public static WriteTypeNameCallback WriteTypeName(ProjectionEmitContext context, return new(context, semantics, nameType, forceWriteNamespace); } - /// - /// Convenience overload of - /// that leases an from , - /// emits the projected type name into it, and returns the resulting string. - /// - /// The active emit context. - /// The semantic representation of the type. - /// The emitted projected type name. - public static string WriteProjectionType(ProjectionEmitContext context, TypeSemantics semantics) + /// + /// A callback that writes the projected type name to the writer it's appended to. + public static WriteProjectionTypeCallback WriteProjectionType(ProjectionEmitContext context, TypeSemantics semantics) { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteProjectionType(writer, context, semantics); - return writer.ToString(); + return new(context, semantics); } /// From 04ba16c5c8b62ad85fc74592a776378ed93c609c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:57:40 -0700 Subject: [PATCH 034/171] Add WriteInterfaceTypeNameForCcwCallback and use it at 4 call sites Add a 1:1 callback wrapper for ClassMembersFactory.WriteInterfaceTypeNameForCcw(IndentedTextWriter, ProjectionEmitContext, ITypeDefOrRef) + a same-named factory overload with . Migrate the 4 inline writer-taking call sites (AbiInterfaceIDicFactory.cs:491, ClassMembersFactory.WriteClassMembers.cs:181, ClassMembersFactory.WriteInterfaceMembers.cs:103, :386) to use the callback as an interpolation hole. The site at ClassMembersFactory.WriteInterfaceMembers.cs:386 combines naturally with M1+M2's WriteProjectionReturnTypeCallback + WriteParameterListCallback locals to fully collapse the overridable explicit-interface DIM thunk to a single writer.Write($"...{ret} {iface}.{name}({parms}) => ...") call. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 5 ++--- .../WriteInterfaceTypeNameForCcwCallback.cs | 20 +++++++++++++++++++ .../ClassMembersFactory.WriteClassMembers.cs | 6 +++--- ...assMembersFactory.WriteInterfaceMembers.cs | 10 ++++------ .../Factories/ClassMembersFactory.cs | 8 ++++++++ 5 files changed, 37 insertions(+), 12 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteInterfaceTypeNameForCcwCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 02c4851b7..c231d4929 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -487,9 +487,8 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite if (baseIfaceWithGetter is not null) { - writer.Write(" get { return (("); - ClassMembersFactory.WriteInterfaceTypeNameForCcw(writer, context, baseIfaceWithGetter); - writer.WriteLine($")(WindowsRuntimeObject)this).{pname}; }}"); + WriteInterfaceTypeNameForCcwCallback iface = ClassMembersFactory.WriteInterfaceTypeNameForCcw(context, baseIfaceWithGetter); + writer.WriteLine($" get {{ return (({iface})(WindowsRuntimeObject)this).{pname}; }}"); } } diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteInterfaceTypeNameForCcwCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteInterfaceTypeNameForCcwCallback.cs new file mode 100644 index 000000000..7cf543560 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteInterfaceTypeNameForCcwCallback.cs @@ -0,0 +1,20 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteInterfaceTypeNameForCcwCallback( + ProjectionEmitContext context, + ITypeDefOrRef ifaceType) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + ClassMembersFactory.WriteInterfaceTypeNameForCcw(writer, context, ifaceType); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index 79543f3de..af6a9d797 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; @@ -177,9 +178,8 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo // T InterfaceName.PropName { set => PropName = value; } if (s.IsOverridable && s.OverridableInterface is not null) { - writer.Write($"{s.PropTypeText} "); - WriteInterfaceTypeNameForCcw(writer, context, s.OverridableInterface); - writer.Write($".{kvp.Key} {{"); + WriteInterfaceTypeNameForCcwCallback iface = WriteInterfaceTypeNameForCcw(context, s.OverridableInterface); + writer.Write($"{s.PropTypeText} {iface}.{kvp.Key} {{"); if (s.HasGetter) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index c60124d3b..d36f16d29 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -98,11 +98,10 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr if (IsInterfaceInInheritanceList(context.Cache, impl, includeExclusiveInterface: false) && !context.Settings.ReferenceProjection) { string giObjRefName = ObjRefNameGenerator.GetObjRefName(context, substitutedInterface); + WriteInterfaceTypeNameForCcwCallback iface = WriteInterfaceTypeNameForCcw(context, substitutedInterface); writer.WriteLine(); - writer.Write("WindowsRuntimeObjectReferenceValue IWindowsRuntimeInterface<"); - WriteInterfaceTypeNameForCcw(writer, context, substitutedInterface); writer.WriteLine(isMultiline: true, $$""" - >.GetInterface() + WindowsRuntimeObjectReferenceValue IWindowsRuntimeInterface<{{iface}}>.GetInterface() { return {{giObjRefName}}.AsValue(); } @@ -382,9 +381,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); - writer.Write($"{ret} "); - WriteInterfaceTypeNameForCcw(writer, context, originalInterface); - writer.Write($".{name}({parms}) => {name}("); + WriteInterfaceTypeNameForCcwCallback iface = WriteInterfaceTypeNameForCcw(context, originalInterface); + writer.Write($"{ret} {iface}.{name}({parms}) => {name}("); for (int i = 0; i < sig.Parameters.Count; i++) { writer.WriteIf(i > 0, ", "); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 3e8d8df3a..86d5a5ef1 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -3,6 +3,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -164,4 +165,11 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro writer.Write(">"); } } + + /// + /// A callback that writes the CCW interface type name to the writer it's appended to. + internal static WriteInterfaceTypeNameForCcwCallback WriteInterfaceTypeNameForCcw(ProjectionEmitContext context, ITypeDefOrRef ifaceType) + { + return new(context, ifaceType); + } } From dcc78f40a88b51acb349d51189430ed59123b157 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 12:59:54 -0700 Subject: [PATCH 035/171] Extract AbiTypeHelpers.GetAbiLocalTypeName and apply at 3 RcwCaller sites Three near-identical ABI-type-selection dispatches in AbiMethodBodyFactory.RcwCaller.cs (out-param default at :376-396, ReceiveArray element type at :419-436, SzArray retval element type at :514-538) all map a TypeSignature to its ABI local C# type name ('void*' / 'global::ABI.System.Type' / 'global::ABI.System.Exception' / ABI struct name / mapped ABI name / blittable struct name / primitive). Extract a single helper 'AbiTypeHelpers.GetAbiLocalTypeName(IndentedTextWriter, ProjectionEmitContext, TypeSignature)' that performs the unified dispatch and call it from each of the three sites, replacing each 18-25 line if/else block with a single 'string abi = AbiTypeHelpers.GetAbiLocalTypeName(...); writer.WriteLine($"{abi}...");' pair. The merged report's 4th candidate site (writeback expression at :1146- 1221) is a different pattern (marshaller call expression, not type name) and is not part of this extraction. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AbiMethodBodyFactory.RcwCaller.cs | 72 ++----------------- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 48 +++++++++++++ 2 files changed, 54 insertions(+), 66 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index a88e28668..dfaff6fb8 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -374,28 +374,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); writer.Write(" "); - if (uOut.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uOut) || uOut.IsObject() || uOut.IsGenericInstance()) - { - writer.Write("void*"); - } - else if (uOut.IsSystemType()) - { - writer.Write("global::ABI.System.Type"); - } - else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) - { - writer.Write(AbiTypeHelpers.GetAbiStructTypeName(writer, context, uOut)); - } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(uOut)) - { - writer.Write(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, uOut)); - } - else - { - writer.Write(AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uOut)); - } - - writer.WriteLine($" __{localName} = default;"); + string abi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, uOut); + writer.WriteLine($"{abi} __{localName} = default;"); } // Declare locals for ReceiveArray params (uint length + element pointer). @@ -417,24 +397,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec """); // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. - if (sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject()) - { - writer.Write("void*"); - } - else if (context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType)) - { - writer.Write(AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType)); - } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType)) - { - writer.Write(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType)); - } - else - { - writer.Write(AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType)); - } - - writer.WriteLine($"* __{localName}_data = default;"); + string elemAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, sza.BaseType); + writer.WriteLine($"{elemAbi}* __{localName}_data = default;"); } // Declare InlineArray16 + ArrayPool fallback for non-blittable PassArray params @@ -511,32 +475,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec uint __retval_length = default; """); - if (retSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSz.BaseType) || retSz.BaseType.IsObject()) - { - writer.Write("void*"); - } - else if (context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType)) - { - writer.Write(AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType)); - } - else if (retSz.BaseType.IsHResultException()) - { - writer.Write("global::ABI.System.Exception"); - } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType)) - { - writer.Write(AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType)); - } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType)) - { - writer.Write(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType)); - } - else - { - writer.Write(AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType)); - } - - writer.WriteLine("* __retval_data = default;"); + string retElemAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, retSz.BaseType); + writer.WriteLine($"{retElemAbi}* __retval_data = default;"); } else if (returnIsHResultException) { diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index b0997b6f7..9f85a3d0c 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -14,6 +14,54 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; internal static partial class AbiTypeHelpers { + /// + /// Returns the ABI C# type name for a local variable that holds the ABI value of a parameter + /// or return type. Encapsulates the type-selection dispatch that's repeated across the RcwCaller + /// out-parameter, ReceiveArray-element, and SzArray-return code paths: reference types + /// (string/interface/object/generic instance) → void*; system type → global::ABI.System.Type; + /// HResult/Exception → global::ABI.System.Exception; complex struct → ABI struct name; + /// mapped value type (DateTime/TimeSpan/etc.) → mapped ABI name; blittable struct → projected + /// name; primitive → fundamental C# keyword. + /// + /// The writer (carried through for the struct-name helpers that accept it; not used to emit). + /// The active emit context. + /// The type signature whose ABI local type name is requested. + /// The ABI C# type name as a string (no trailing punctuation). + internal static string GetAbiLocalTypeName(IndentedTextWriter writer, ProjectionEmitContext context, TypeSignature sig) + { + if (sig.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sig) || sig.IsObject() || sig.IsGenericInstance()) + { + return "void*"; + } + + if (sig.IsSystemType()) + { + return "global::ABI.System.Type"; + } + + if (sig.IsHResultException()) + { + return "global::ABI.System.Exception"; + } + + if (context.AbiTypeShapeResolver.IsComplexStruct(sig)) + { + return GetAbiStructTypeName(writer, context, sig); + } + + if (IsMappedAbiValueType(sig)) + { + return GetMappedAbiTypeName(sig); + } + + if (context.AbiTypeShapeResolver.IsBlittableStruct(sig)) + { + return GetBlittableStructAbiType(writer, context, sig); + } + + return GetAbiPrimitiveType(context.Cache, sig); + } + /// /// Returns the ABI type name for a blittable struct (the projected type name). /// From 60261d1e9c7b8fe53f8ffdaad6887f4771630926 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:01:27 -0700 Subject: [PATCH 036/171] Collapse DoAbi branch dispatches: out-param default + out-param writeback Two branch-consolidation cleanups in AbiMethodBodyFactory.DoAbi.cs: 1. Lines 175-196 (default-initialized return local): the previous 4-branch if/else (returnIsString -> "string"; returnIsRefType, returnIsReceiveArrayDoAbi, and the default -> projected signature) had three branches that emitted identical 'WriteProjectedSignatureCallback projected = ...; writer.WriteLine($"{projected} ...")' code. Collapse into 'if (returnIsString) string-literal; else projected-callback'. 2. Lines 534-588 (per-parameter writeback to ABI struct slot): the previous 8-branch if/else (string / object / runtime-class-or-interface / generic instance / enum / bool / char / complex-struct / default) each wrote a 'writer.Write(" *ptr = "); writer.Write(rhs); writer.WriteLine(";");' triplet where 'rhs' is a small string expression. Hoist 'rhs' into a 'string rhs' local computed by the if/else, then emit 'writer.WriteLine($" *{ptr} = {rhs};");' once. The enum, bool, char, and default branches all produced the same '__{raw}' RHS so they merge into one default-branch. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 45 ++++++------------- 1 file changed, 13 insertions(+), 32 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 5f66a979e..f54537262 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -178,18 +178,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { writer.WriteLine($"string {retLocalName} = default;"); } - else if (returnIsRefType) - { - WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, rt, false); - writer.WriteLine($"{projected} {retLocalName} = default;"); - } - else if (returnIsReceiveArrayDoAbi) - { - WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, rt, false); - writer.WriteLine($"{projected} {retLocalName} = default;"); - } else { + // returnIsRefType, returnIsReceiveArrayDoAbi, and the default branch all emit + // the same projected type for the default-initialized return local. WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine($"{projected} {retLocalName} = default;"); } @@ -532,46 +524,34 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - writer.Write($" *{ptr} = "); + string rhs; // String: HStringMarshaller.ConvertToUnmanaged if (underlying.IsString()) { - writer.Write($"HStringMarshaller.ConvertToUnmanaged(__{raw})"); + rhs = $"HStringMarshaller.ConvertToUnmanaged(__{raw})"; } // Object/runtime class: .ConvertToUnmanaged(...).DetachThisPtrUnsafe() else if (underlying.IsObject()) { - writer.Write($"WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(__{raw}).DetachThisPtrUnsafe()"); + rhs = $"WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(__{raw}).DetachThisPtrUnsafe()"; } else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(underlying)) { - writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw}).DetachThisPtrUnsafe()"); + rhs = $"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw}).DetachThisPtrUnsafe()"; } // Generic instance (e.g. IEnumerable): use the hoisted UnsafeAccessor // 'ConvertToUnmanaged_' declared at the top of the method body. else if (underlying.IsGenericInstance()) { - writer.Write($"ConvertToUnmanaged_{raw}(null, __{raw}).DetachThisPtrUnsafe()"); + rhs = $"ConvertToUnmanaged_{raw}(null, __{raw}).DetachThisPtrUnsafe()"; } // For enums, function pointer signature uses the projected enum type, no cast needed. // For bool, cast to byte. For char, cast to ushort. - else if (context.AbiTypeShapeResolver.IsEnumType(underlying)) - { - writer.Write($"__{raw}"); - } - else if (underlying is CorLibTypeSignature corlibBool && - corlibBool.ElementType == ElementType.Boolean) - { - writer.Write($"__{raw}"); - } - else if (underlying is CorLibTypeSignature corlibChar && - corlibChar.ElementType == ElementType.Char) - { - writer.Write($"__{raw}"); - } + // For the local managed value, marshal through Marshaller.ConvertToUnmanaged + // before writing it into the *out ABI struct slot. // Non-blittable struct (e.g. authored BasicStruct with string fields): marshal // the local managed value through Marshaller.ConvertToUnmanaged before @@ -579,13 +559,14 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection //: "Marshaller.ConvertToUnmanaged(local)". else if (context.AbiTypeShapeResolver.IsComplexStruct(underlying)) { - writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw})"); + rhs = $"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw})"; } else { - writer.Write($"__{raw}"); + // Enums, bool, char, and primitives: the local __ is already the ABI form. + rhs = $"__{raw}"; } - writer.WriteLine(";"); + writer.WriteLine($" *{ptr} = {rhs};"); } // After call: for ReceiveArray params, emit ConvertToUnmanaged_ call (the From a31ffc536c14c14b86eb9aa8390db2934c7bb019 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:02:34 -0700 Subject: [PATCH 037/171] Collapse 4 ConstructorFactory.Composable base-chaining ctors via table ConstructorFactory.Composable.WriteComposableConstructors emitted 4 near-identical 'protected T(...) :base(...) { ... }' blocks that differed only in the constructor's parameter list and matching ':base(...)' argument list. Replace the 4 duplicated WriteLine + WriteBlock blocks with a 4-entry '(string parameters, string baseArgs)[]' table iterated in a single foreach. Eliminates ~30 lines of duplication while preserving the exact emission (including the optional GC.AddMemoryPressure body line gated on 'gcPressureBody'). Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ConstructorFactory.Composable.cs | 61 +++++++------------ 1 file changed, 23 insertions(+), 38 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 32be0f500..645b1a3db 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -154,45 +154,30 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec ? "GC.AddMemoryPressure(" + gcPressure.ToString(CultureInfo.InvariantCulture) + ");" : string.Empty; - // 1. WindowsRuntimeActivationTypes.DerivedComposed - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - protected {{typeName}}(WindowsRuntimeActivationTypes.DerivedComposed _, WindowsRuntimeObjectReference activationFactoryObjectReference, in Guid iid, CreateObjectReferenceMarshalingType marshalingType) - :base(_, activationFactoryObjectReference, in iid, marshalingType) - """); - using (writer.WriteBlock()) + // Each entry pairs the constructor's parameter list with the matching ':base(...)' arg list. + (string Parameters, string BaseArgs)[] ctorSignatures = + [ + ("WindowsRuntimeActivationTypes.DerivedComposed _, WindowsRuntimeObjectReference activationFactoryObjectReference, in Guid iid, CreateObjectReferenceMarshalingType marshalingType", + "_, activationFactoryObjectReference, in iid, marshalingType"), + ("WindowsRuntimeActivationTypes.DerivedSealed _, WindowsRuntimeObjectReference activationFactoryObjectReference, in Guid iid, CreateObjectReferenceMarshalingType marshalingType", + "_, activationFactoryObjectReference, in iid, marshalingType"), + ("WindowsRuntimeActivationFactoryCallback.DerivedComposed activationFactoryCallback, in Guid iid, CreateObjectReferenceMarshalingType marshalingType, WindowsRuntimeActivationArgsReference additionalParameters", + "activationFactoryCallback, in iid, marshalingType, additionalParameters"), + ("WindowsRuntimeActivationFactoryCallback.DerivedSealed activationFactoryCallback, in Guid iid, CreateObjectReferenceMarshalingType marshalingType, WindowsRuntimeActivationArgsReference additionalParameters", + "activationFactoryCallback, in iid, marshalingType, additionalParameters"), + ]; + + foreach ((string parameters, string baseArgs) in ctorSignatures) { - writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); - } - - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - protected {{typeName}}(WindowsRuntimeActivationTypes.DerivedSealed _, WindowsRuntimeObjectReference activationFactoryObjectReference, in Guid iid, CreateObjectReferenceMarshalingType marshalingType) - :base(_, activationFactoryObjectReference, in iid, marshalingType) - """); - using (writer.WriteBlock()) - { - writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); - } - - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - protected {{typeName}}(WindowsRuntimeActivationFactoryCallback.DerivedComposed activationFactoryCallback, in Guid iid, CreateObjectReferenceMarshalingType marshalingType, WindowsRuntimeActivationArgsReference additionalParameters) - :base(activationFactoryCallback, in iid, marshalingType, additionalParameters) - """); - using (writer.WriteBlock()) - { - writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); - } - - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - protected {{typeName}}(WindowsRuntimeActivationFactoryCallback.DerivedSealed activationFactoryCallback, in Guid iid, CreateObjectReferenceMarshalingType marshalingType, WindowsRuntimeActivationArgsReference additionalParameters) - :base(activationFactoryCallback, in iid, marshalingType, additionalParameters) - """); - using (writer.WriteBlock()) - { - writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); + writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" + protected {{typeName}}({{parameters}}) + :base({{baseArgs}}) + """); + using (writer.WriteBlock()) + { + writer.WriteLineIf(!string.IsNullOrEmpty(gcPressureBody), gcPressureBody); + } } } } From 25d9a420853355c0a955d44b70a0c2283a9cbc38 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:03:48 -0700 Subject: [PATCH 038/171] Consolidate event-accessor branches via 'string accessors' local Both ClassFactory.WriteStaticClass (static event emission at :385-407) and ClassMembersFactory.WriteInterfaceMembers.WriteEventEmission (:565-596) had the same pattern: emit the event declaration header in one multiline raw string, then branch on emit context to select the accessor body, then emit a trailing '}'. Lift the branched accessor body into a 'string accessors' local computed by the if/else, then emit the whole event declaration in one interpolated multiline raw string with the '{{accessors}}' hole. The reader can now see the full emitted event shape (header + body + closing brace) in one writer call rather than reconstructing it across three separate WriteLines. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ClassFactory.cs | 27 ++++++++----------- ...assMembersFactory.WriteInterfaceMembers.cs | 24 +++++++++-------- 2 files changed, 24 insertions(+), 27 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index cfb520419..85a598436 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -384,26 +384,21 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); - writer.WriteLine(isMultiline: true, $$""" - public static event {{eventType}} {{evtName}} - { - """); - if (context.Settings.ReferenceProjection) - { - // event accessor bodies become 'throw null' in reference projection mode. - writer.WriteLine(isMultiline: true, """ + string accessors = context.Settings.ReferenceProjection + ? """ add => throw null; remove => throw null; - """); - } - else - { - writer.WriteLine(isMultiline: true, $$""" + """ + : $$""" add => {{abiClass}}.{{evtName}}({{objRef}}, {{objRef}}).Subscribe(value); remove => {{abiClass}}.{{evtName}}({{objRef}}, {{objRef}}).Unsubscribe(value); - """); - } - writer.WriteLine("}"); + """; + writer.WriteLine(isMultiline: true, $$""" + public static event {{eventType}} {{evtName}} + { + {{accessors}} + } + """); } // Properties (merge getter/setter across interfaces, tracking origin per accessor) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index d36f16d29..c74cf8a76 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -563,23 +563,20 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt, currentInstance); - writer.WriteLine(isMultiline: true, $$""" - {{access}}{{methodSpec}}event {{eventType}} {{name}} - { - """); + string accessors; if (context.Settings.ReferenceProjection) { - writer.WriteLine(isMultiline: true, """ + accessors = """ add => throw null; remove => throw null; - """); + """; } else if (inlineEventSourceField) { - writer.WriteLine(isMultiline: true, $$""" + accessors = $$""" add => _eventSource_{{name}}.Subscribe(value); remove => _eventSource_{{name}}.Unsubscribe(value); - """); + """; } else { @@ -588,12 +585,17 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // inline_event_source_field is false (the default helper-based path). // Example: Simple.Event0 (on ISimple5) becomes // add => global::ABI.test_component_fast.ISimpleMethods.Event0((WindowsRuntimeObject)this, _objRef_test_component_fast_ISimple).Subscribe(value); - writer.WriteLine(isMultiline: true, $$""" + accessors = $$""" add => {{abiClass}}.{{name}}((WindowsRuntimeObject)this, {{objRef}}).Subscribe(value); remove => {{abiClass}}.{{name}}((WindowsRuntimeObject)this, {{objRef}}).Unsubscribe(value); - """); + """; } - writer.WriteLine("}"); + writer.WriteLine(isMultiline: true, $$""" + {{access}}{{methodSpec}}event {{eventType}} {{name}} + { + {{accessors}} + } + """); } } } From 51fcac5639190fb542d69d065ac7cd29e10c02ea Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:39:02 -0700 Subject: [PATCH 039/171] M15: Consolidate ComponentFactory factory-class emission via 'activateBody' local Collapse the chunked Write/WriteLine calls that emit a factory class body in ComponentFactory.WriteFactoryClass into a single multi-line interpolated raw string. The conditional ActivateInstance body (one of two single-line expressions) is hoisted into a string local and inlined via {{activateBody}}. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ComponentFactory.cs | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 1ea8871bb..41135dea0 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -79,6 +79,9 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo TypedefNameWriter.WriteTypedefName(writer, context, iface, TypedefNameType.CCW, false); TypedefNameWriter.WriteTypeParams(writer, iface); } + string activateBody = isActivatable + ? $"return new {projectedTypeName}();" + : "throw new NotImplementedException();"; writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" { @@ -98,18 +101,9 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo public object ActivateInstance() { + {{activateBody}} + } """); - if (isActivatable) - { - writer.Write($"return new {projectedTypeName}();"); - } - else - { - writer.Write("throw new NotImplementedException();"); - } - - writer.WriteLine(); - writer.WriteLine("}"); // Emit factory-class members: forwarding methods/properties/events for static factory // interfaces, and constructor wrappers for activatable factory interfaces. From 4628066f732d03bb61336f4370b886189d0be3b0 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:42:05 -0700 Subject: [PATCH 040/171] M16: WriteAbiParameterTypesPointerCallback Add WriteAbiParameterTypesPointerCallback + factory overload on AbiInterfaceFactory and migrate the 4 call sites: - AbiInterfaceFactory.WriteInterfaceVftbl: vtable function-pointer declaration in vftbl struct (was: Write/WriteAbi/WriteLine chunked emission, now: single interpolated WriteLine with {abiParams} hole). - AbiInterfaceFactory.WriteInterfaceImpl Do_Abi emission: multiline raw string ending in 'Do_Abi_X(' + WriteAbi + Write(')') -> single interpolated multiline ending in 'Do_Abi_X({abiParams})'. - AbiDelegateFactory.WriteDelegateImpl Invoke emission: same shape as Do_Abi - merged into a single multiline raw string. - AbiDelegateFactory.WriteDelegateVftbl: 'delegate*<' + WriteAbi + ', int> Invoke;' -> single multiline raw string with {invokeParams} inline between '<' and ', int>'. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 14 ++++------- .../Factories/AbiInterfaceFactory.cs | 17 +++++++++----- .../WriteAbiParameterTypesPointerCallback.cs | 23 +++++++++++++++++++ 3 files changed, 39 insertions(+), 15 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiParameterTypesPointerCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 8e1913075..374f9afce 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -71,6 +71,7 @@ private static void WriteDelegateImpl(IndentedTextWriter writer, ProjectionEmitC string nameStripped = IdentifierEscaping.StripBackticks(name); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); + WriteAbiParameterTypesPointerCallback invokeParams = AbiInterfaceFactory.WriteAbiParameterTypesPointer(context, sig, includeParamNames: true); writer.WriteLine(); writer.Write(isMultiline: true, $$""" internal static unsafe class {{nameStripped}}Impl @@ -91,10 +92,8 @@ public static nint Vtable } [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] - private static int Invoke( + private static int Invoke({{invokeParams}}) """); - AbiInterfaceFactory.WriteAbiParameterTypesPointer(writer, context, sig, includeParamNames: true); - writer.Write(")"); // Reuse the interface Do_Abi body emitter: delegates dispatch via __target.Invoke(...), // which is exactly the same shape as interface CCW dispatch. Pass the delegate's @@ -131,19 +130,16 @@ private static void WriteDelegateVftbl(IndentedTextWriter writer, ProjectionEmit string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); + WriteAbiParameterTypesPointerCallback invokeParams = AbiInterfaceFactory.WriteAbiParameterTypesPointer(context, sig); writer.WriteLine(); - writer.Write(isMultiline: true, $$""" + writer.WriteLine(isMultiline: true, $$""" [StructLayout(LayoutKind.Sequential)] internal unsafe struct {{nameStripped}}Vftbl { public delegate* unmanaged[MemberFunction] QueryInterface; public delegate* unmanaged[MemberFunction] AddRef; public delegate* unmanaged[MemberFunction] Release; - public delegate* unmanaged[MemberFunction]< - """); - AbiInterfaceFactory.WriteAbiParameterTypesPointer(writer, context, sig); - writer.WriteLine(isMultiline: true, """ - , int> Invoke; + public delegate* unmanaged[MemberFunction]<{{invokeParams}}, int> Invoke; } """); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 5403460af..94101956d 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -55,6 +55,13 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj WriteAbiParameterTypesPointer(writer, context, sig, includeParamNames: false); } + /// + /// A callback emitting the ABI parameter types. + public static WriteAbiParameterTypesPointerCallback WriteAbiParameterTypesPointer(ProjectionEmitContext context, MethodSignatureInfo sig, bool includeParamNames = false) + { + return new(context, sig, includeParamNames); + } + /// /// Writes the ABI parameter types for a vtable function pointer signature, optionally /// including parameter names (for method declarations vs. function pointer type lists). @@ -217,9 +224,8 @@ internal unsafe struct {{nameStripped}}Vftbl { string vm = AbiTypeHelpers.GetVirtualMethodName(type, method); MethodSignatureInfo sig = new(method); - writer.Write("public delegate* unmanaged[MemberFunction]<"); - WriteAbiParameterTypesPointer(writer, context, sig); - writer.WriteLine($", int> {vm};"); + WriteAbiParameterTypesPointerCallback abiParams = WriteAbiParameterTypesPointer(context, sig); + writer.WriteLine($"public delegate* unmanaged[MemberFunction]<{abiParams}, int> {vm};"); } } } @@ -365,12 +371,11 @@ void EmitOneDoAbi(MethodDefinition method) EventTableFactory.EmitEventTableField(writer, context, evt, ifaceFullName); } + WriteAbiParameterTypesPointerCallback doAbiParams = WriteAbiParameterTypesPointer(context, sig, includeParamNames: true); writer.Write(isMultiline: true, $$""" [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] - private static unsafe int Do_Abi_{{vm}}( + private static unsafe int Do_Abi_{{vm}}({{doAbiParams}}) """); - WriteAbiParameterTypesPointer(writer, context, sig, includeParamNames: true); - writer.Write(")"); if (eventMap is not null && eventMap.TryGetValue(method, out EventDefinition? evt2)) { diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiParameterTypesPointerCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiParameterTypesPointerCallback.cs new file mode 100644 index 000000000..18a61d543 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteAbiParameterTypesPointerCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteAbiParameterTypesPointerCallback( + ProjectionEmitContext context, + MethodSignatureInfo sig, + bool includeParamNames) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + AbiInterfaceFactory.WriteAbiParameterTypesPointer(writer, context, sig, includeParamNames); + } +} From 1b39528fa52ed25b7e88213685d827f4c362b1d8 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:43:22 -0700 Subject: [PATCH 041/171] M17: WriteFactoryMethodParametersCallback + WriteFactoryReturnTypeCallback Add callback structs + factory overloads for ComponentFactory's two factory-method-emission helpers. Both helpers are now public to enable the callback dispatch path. Migrates the 4 WriteFactoryMethodParameters call sites + 1 WriteFactoryReturnType call site: - WriteFactoryActivatableMethod: was 5 chunked Write/WriteLine calls with two embedded parameter-list emissions; now a single WriteLine with two {typedParams}/{nameOnlyParams} callback holes. - WriteStaticFactoryMethod: was 6 chunked Write/WriteLine calls with embedded return-type + two parameter-list emissions; now a single WriteLine with {retType}, {typedParams}, {nameOnlyParams} holes. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../WriteFactoryMethodParametersCallback.cs | 23 ++++++++++ .../WriteFactoryReturnTypeCallback.cs | 22 +++++++++ .../Factories/ComponentFactory.cs | 45 +++++++++++++------ 3 files changed, 76 insertions(+), 14 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryMethodParametersCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryReturnTypeCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryMethodParametersCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryMethodParametersCallback.cs new file mode 100644 index 000000000..706322a9e --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryMethodParametersCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteFactoryMethodParametersCallback( + ProjectionEmitContext context, + MethodDefinition method, + bool includeTypes) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + ComponentFactory.WriteFactoryMethodParameters(writer, context, method, includeTypes); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryReturnTypeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryReturnTypeCallback.cs new file mode 100644 index 000000000..884daa524 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteFactoryReturnTypeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteFactoryReturnTypeCallback( + ProjectionEmitContext context, + MethodDefinition method) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + ComponentFactory.WriteFactoryReturnType(writer, context, method); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 41135dea0..fde681252 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -168,12 +168,10 @@ private static void WriteFactoryActivatableMethod(IndentedTextWriter writer, Pro } string methodName = method.Name?.Value ?? string.Empty; + WriteFactoryMethodParametersCallback typedParams = WriteFactoryMethodParameters(context, method, includeTypes: true); + WriteFactoryMethodParametersCallback nameOnlyParams = WriteFactoryMethodParameters(context, method, includeTypes: false); writer.WriteLine(); - writer.Write($"public {projectedTypeName} {methodName}("); - WriteFactoryMethodParameters(writer, context, method, includeTypes: true); - writer.Write($") => new {projectedTypeName}("); - WriteFactoryMethodParameters(writer, context, method, includeTypes: false); - writer.WriteLine(");"); + writer.WriteLine($"public {projectedTypeName} {methodName}({typedParams}) => new {projectedTypeName}({nameOnlyParams});"); } /// @@ -188,14 +186,11 @@ private static void WriteStaticFactoryMethod(IndentedTextWriter writer, Projecti } string methodName = method.Name?.Value ?? string.Empty; + WriteFactoryReturnTypeCallback retType = WriteFactoryReturnType(context, method); + WriteFactoryMethodParametersCallback typedParams = WriteFactoryMethodParameters(context, method, includeTypes: true); + WriteFactoryMethodParametersCallback nameOnlyParams = WriteFactoryMethodParameters(context, method, includeTypes: false); writer.WriteLine(); - writer.Write("public "); - WriteFactoryReturnType(writer, context, method); - writer.Write($" {methodName}("); - WriteFactoryMethodParameters(writer, context, method, includeTypes: true); - writer.Write($") => {projectedTypeName}.{methodName}("); - WriteFactoryMethodParameters(writer, context, method, includeTypes: false); - writer.WriteLine(");"); + writer.WriteLine($"public {retType} {methodName}({typedParams}) => {projectedTypeName}.{methodName}({nameOnlyParams});"); } /// @@ -257,7 +252,17 @@ private static void WriteStaticFactoryEvent(IndentedTextWriter writer, Projectio """); } - private static void WriteFactoryReturnType(IndentedTextWriter writer, ProjectionEmitContext context, MethodDefinition method) + /// + /// A callback emitting the projected return type of . + public static WriteFactoryReturnTypeCallback WriteFactoryReturnType(ProjectionEmitContext context, MethodDefinition method) + { + return new(context, method); + } + + /// + /// Writes the projected return type for a static-factory forwarding method. + /// + public static void WriteFactoryReturnType(IndentedTextWriter writer, ProjectionEmitContext context, MethodDefinition method) { TypeSignature? returnType = method.Signature?.ReturnType; @@ -284,7 +289,19 @@ private static void WriteFactoryPropertyType(IndentedTextWriter writer, Projecti TypedefNameWriter.WriteTypeName(writer, context, semantics, TypedefNameType.Projected, true); } - private static void WriteFactoryMethodParameters(IndentedTextWriter writer, ProjectionEmitContext context, MethodDefinition method, bool includeTypes) + /// + /// A callback emitting the factory-method parameter list. + public static WriteFactoryMethodParametersCallback WriteFactoryMethodParameters(ProjectionEmitContext context, MethodDefinition method, bool includeTypes) + { + return new(context, method, includeTypes); + } + + /// + /// Writes the parameter list for a factory wrapper/forwarding method. When + /// is , emits 'Type name' + /// pairs; otherwise emits names only (for forwarding call sites). + /// + public static void WriteFactoryMethodParameters(IndentedTextWriter writer, ProjectionEmitContext context, MethodDefinition method, bool includeTypes) { MethodSignature? sig = method.Signature; From b5695e24a6626a3f5598e1d12278385e11eee3e9 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:44:26 -0700 Subject: [PATCH 042/171] M18: WriteGuidAttributeCallback Add WriteGuidAttributeCallback + factory overload on InterfaceFactory and migrate the 2 call sites: - AbiInterfaceIDicFactory.WriteInterfaceIdicImpl: 4 chunked WriteLine + WriteGuidAttribute + WriteLine + WriteLine calls collapsed into a single multi-line interpolated raw string with {guidAttr} and {parent}. - InterfaceFactory.WriteInterface: WriteGuidAttribute + WriteLine pair collapsed into a single WriteLine(\$"{guidAttr}"). Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 10 ++++++---- .../Callbacks/WriteGuidAttributeCallback.cs | 19 +++++++++++++++++++ .../Factories/InterfaceFactory.cs | 11 +++++++++-- 3 files changed, 34 insertions(+), 6 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidAttributeCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index c231d4929..f03e9776c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -39,12 +39,14 @@ public static void WriteInterfaceIdicImpl(IndentedTextWriter writer, ProjectionE string name = type.Name?.Value ?? string.Empty; string nameStripped = IdentifierEscaping.StripBackticks(name); WriteTypedefNameWithTypeParamsCallback parent = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); + WriteGuidAttributeCallback guidAttr = InterfaceFactory.WriteGuidAttribute(type); writer.WriteLine(); - writer.WriteLine("[DynamicInterfaceCastableImplementation]"); - InterfaceFactory.WriteGuidAttribute(writer, type); - writer.WriteLine(); - writer.WriteLine($"file interface {nameStripped} : {parent}"); + writer.WriteLine(isMultiline: true, $$""" + [DynamicInterfaceCastableImplementation] + {{guidAttr}} + file interface {{nameStripped}} : {{parent}} + """); using (writer.WriteBlock()) { // Emit DIM bodies that dispatch through the static ABI Methods class. diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidAttributeCallback.cs new file mode 100644 index 000000000..da3a067f0 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidAttributeCallback.cs @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteGuidAttributeCallback(TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + InterfaceFactory.WriteGuidAttribute(writer, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 454704306..c020cd689 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -21,6 +21,13 @@ namespace WindowsRuntime.ProjectionWriter.Factories; /// internal static class InterfaceFactory { + /// + /// A callback emitting the [Guid("...")] attribute. + public static WriteGuidAttributeCallback WriteGuidAttribute(TypeDefinition type) + { + return new(type); + } + /// /// Writes the [Guid("...")] attribute for a type. /// @@ -471,8 +478,8 @@ public static void WriteInterface(IndentedTextWriter writer, ProjectionEmitConte writer.WriteLine(); MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - WriteGuidAttribute(writer, type); - writer.WriteLine(); + WriteGuidAttributeCallback guidAttr = WriteGuidAttribute(type); + writer.WriteLine($"{guidAttr}"); CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); bool isInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) || From 10f34832efd36bfd9a4952eeee06cc830d460530 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Sat, 16 May 2026 13:45:41 -0700 Subject: [PATCH 043/171] M19a: WriteParameterNameWithModifierCallback (per-element) Add a per-element WriteParameterNameWithModifierCallback and factory overload on ClassMembersFactory. Migrates the 6 in-loop call sites that were emitting an argument list one parameter at a time: - AbiInterfaceIDicFactory.WriteIdicForwardingMethod (2 loops) - ClassMembersFactory.WriteInterfaceMembers (3 loops) - ClassFactory.WriteStaticInterfaceMember (1 loop) Each loop body now consists of a single Write(\$"{sep}{p}") call (where 'sep' is either ", " or "" depending on element index and whether the loop has a leading separator), keeping the per-element shape readable and the 1:1 callback wrapper convention consistent with the rest of the codebase. Output is byte-identical for all 10 generated files in the refgen-pushnot scenario. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 9 ++++---- .../WriteParameterNameWithModifierCallback.cs | 22 +++++++++++++++++++ .../Factories/ClassFactory.cs | 4 ++-- ...assMembersFactory.WriteInterfaceMembers.cs | 13 +++++------ .../Factories/ClassMembersFactory.cs | 7 ++++++ 5 files changed, 41 insertions(+), 14 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterNameWithModifierCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index f03e9776c..4714f5018 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -306,9 +306,8 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented writer.Write($"{ret} {ccwIfaceName}.{mname}({parms}) => (({ccwIfaceName})(WindowsRuntimeObject)this).{mname}("); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.WriteIf(i > 0, ", "); - - ClassMembersFactory.WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); + WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($"{(i > 0 ? ", " : "")}{p}"); } writer.WriteLine(");"); } @@ -446,8 +445,8 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite writer.Write($"{abiClass}.{mname}(_obj"); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.Write(", "); - ClassMembersFactory.WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); + WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($", {p}"); } writer.WriteLine(isMultiline: true, """ ); diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterNameWithModifierCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterNameWithModifierCallback.cs new file mode 100644 index 000000000..f605559e8 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteParameterNameWithModifierCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteParameterNameWithModifierCallback( + ProjectionEmitContext context, + ParameterInfo parameter) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + ClassMembersFactory.WriteParameterNameWithModifier(writer, context, parameter); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 85a598436..42e42df2b 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -368,8 +368,8 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection writer.Write($") => {abiClass}.{mname}({objRef}"); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.Write(", "); - ClassMembersFactory.WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); + WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($", {p}"); } writer.WriteLine(");"); } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index c74cf8a76..24f6b9025 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -339,8 +339,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE writer.Write($") => {accessorName}(null, {objRef}"); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.Write(", "); - WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); + WriteParameterNameWithModifierCallback p = WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($", {p}"); } writer.WriteLine(");"); } @@ -365,8 +365,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE writer.Write($") => {abiClass}.{name}({objRef}"); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.Write(", "); - WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); + WriteParameterNameWithModifierCallback p = WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($", {p}"); } writer.WriteLine(");"); } @@ -385,9 +385,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE writer.Write($"{ret} {iface}.{name}({parms}) => {name}("); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.WriteIf(i > 0, ", "); - - WriteParameterNameWithModifier(writer, context, sig.Parameters[i]); + WriteParameterNameWithModifierCallback p = WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($"{(i > 0 ? ", " : "")}{p}"); } writer.WriteLine(");"); } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 86d5a5ef1..d657115be 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -86,6 +86,13 @@ internal static bool IsInterfaceInInheritanceList(MetadataCache cache, Interface return null; } + /// + /// A callback emitting the parameter name with its modifier. + internal static WriteParameterNameWithModifierCallback WriteParameterNameWithModifier(ProjectionEmitContext context, ParameterInfo p) + { + return new(context, p); + } + /// /// Writes a parameter name prefixed with its modifier (in/out/ref) for use as a call argument. /// From ac219bf40905872c9911beb6391bbdf0b544264b Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 13:40:05 -0700 Subject: [PATCH 044/171] Suppress blank lines from empty interpolation holes in multiline writes When a multiline interpolated raw string in `IndentedTextWriter` contains an interpolation hole that expands to empty content, the multiline parser previously still emitted the line's terminating newline, producing a stray blank line in the output. This commit makes the `AppendInterpolatedStringHandler` collapse those would-be blank lines unconditionally. This is needed to make conditional callback emission work cleanly inside a single multiline interpolated template. Concretely, the pattern that will be unlocked by this is: writer.WriteLine(isMultiline: true, $$""" [WindowsRuntimeMetadata("...")] {{valueTypeAttr}} {{refTypeAttr}} {{comWrappersAttr}} public class Foo """); where the conditional attribute callbacks (which early-return based on `ReferenceProjection` / other build configuration) may expand to empty. Without the collapse rule, each empty hole would emit a stray blank line into the output, breaking byte-identical generation. The behavior is always on (no opt-in flag) so callers do not have to think about whether their template needs it. Implementation: - The `AppendInterpolatedStringHandler` struct drops its `readonly` qualifier (already passed everywhere by `ref`) so it can carry the mutable `_anyContentBetweenLiterals` tracker used by the suppress rule. The existing two constructors are unchanged. - `AppendLiteral` checks the suppress condition (previous buffer ended with newline + no formatted content since the last literal + this literal starts with a newline) and, if all three hold, slices off the leading newline. Slicing uses a local `ReadOnlySpan` so there is no string allocation, and dispatches to the existing `IndentedTextWriter.Write(bool, ReadOnlySpan)` overload. Both LF and CRLF line endings are matched (raw-string literals inherit the source file's line endings; CR-only is not supported). - All four `AppendFormatted` overloads now capture buffer length before/after their work and set `_anyContentBetweenLiterals` when the buffer grew, so the suppress check can decide whether the intervening holes contributed any content. - Literal blank lines (e.g. a deliberate blank line inside a single raw-string segment) are always preserved because they are emitted by the multiline parser in one streaming pass without the suppress rule getting a chance to fire between them. Validation: - Adds an `InternalsVisibleTo("WinRT.Projection.Writer.TestRunner")` entry to the writer project so the test runner can construct an `IndentedTextWriter` directly. - Adds a `smoke` command to the test runner that exercises 10 scenarios covering: all-empty middle holes, partial-empty mix, all non-empty (no suppression), literal blank line preservation, multiple empty holes on one line, leading empty hole at buffer start, `Write` vs `WriteLine`, indented writer, literal-only templates, and string-callback empty-emission parity. All 10 pass. - Re-runs the full projection writer harness against the three validation scenarios (refgen-pushnot / refgen-everything-with-ui / refgen-windows): 763/763 generated `.cs` files are byte-identical to the pre-change baseline, confirming that no existing call site relied on the previous "empty hole produces a blank line" behavior. - `dotnet publish -r win-x64` of `WinRT.Projection.Generator` (Native AOT) succeeds clean. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Program.cs | 204 ++++++++++++++++++ .../WinRT.Projection.Writer.csproj | 4 + ...tWriter.AppendInterpolatedStringHandler.cs | 108 ++++++++-- 3 files changed, 302 insertions(+), 14 deletions(-) diff --git a/src/WinRT.Projection.Writer.TestRunner/Program.cs b/src/WinRT.Projection.Writer.TestRunner/Program.cs index 86dbcd298..319f81edc 100644 --- a/src/WinRT.Projection.Writer.TestRunner/Program.cs +++ b/src/WinRT.Projection.Writer.TestRunner/Program.cs @@ -40,6 +40,10 @@ public static int Main(string[] args) { return RunRsp(args[1], refMode); } + if (args.Length >= 1 && args[0] == "smoke") + { + return RunSmoke(); + } return RunSimple(args); } @@ -467,5 +471,205 @@ private static int RunCompareAuthoring(string output) Console.WriteLine($"Generated {Directory.GetFiles(output, "*.cs").Length} files in {output}"); return 0; } + + /// + /// Smoke tests for the suppressEmptyLines overload on + /// 's interpolated + /// string handler. Validates that: + /// + /// When all interpolation holes on a template line expand to empty content, the line's + /// blank residue is suppressed (no stray newline emitted). + /// When at least one hole on a line emits content, no suppression occurs. + /// Literal blank lines in the template (consecutive newlines not separated by a hole) + /// are always preserved. + /// The legacy overload (without suppressEmptyLines) behaves identically to before. + /// + /// + private static int RunSmoke() + { + int failures = 0; + + WindowsRuntime.ProjectionWriter.Writers.IndentedTextWriter Make() => + new WindowsRuntime.ProjectionWriter.Writers.IndentedTextWriter(); + + // Test cases: each is (description, action_producing_string, expected_string). + var tests = new System.Collections.Generic.List<(string desc, Func actual, string expected)> + { + // Case 1: all 3 attribute holes empty → only header remains. + ("S1: all-empty middle holes collapse to nothing", + () => { + var w = Make(); + string a = string.Empty, b = string.Empty, c = string.Empty; + w.WriteLine(isMultiline: true, $$""" + [Header] + {{a}} + {{b}} + {{c}} + public class Foo + """); + return w.ToString(); + }, + "[Header]\npublic class Foo\n"), + + // Case 2: first hole non-empty, others empty → first kept, others collapsed. + ("S2: partial-empty holes collapse only the empty ones", + () => { + var w = Make(); + string a = "[A]", b = string.Empty, c = string.Empty; + w.WriteLine(isMultiline: true, $$""" + [Header] + {{a}} + {{b}} + {{c}} + public class Foo + """); + return w.ToString(); + }, + "[Header]\n[A]\npublic class Foo\n"), + + // Case 3: all holes non-empty → every line preserved. + ("S3: all-non-empty holes preserved", + () => { + var w = Make(); + string a = "[A]", b = "[B]", c = "[C]"; + w.WriteLine(isMultiline: true, $$""" + [Header] + {{a}} + {{b}} + {{c}} + public class Foo + """); + return w.ToString(); + }, + "[Header]\n[A]\n[B]\n[C]\npublic class Foo\n"), + + // Case 4: literal blank line preserved (no hole between newlines). + ("S4: literal blank line is preserved (no hole between newlines)", + () => { + var w = Make(); + string a = "[A]"; + w.WriteLine(isMultiline: true, $$""" + Line1 + + {{a}} + Line3 + """); + return w.ToString(); + }, + "Line1\n\n[A]\nLine3\n"), + + // Case 5: multiple empty holes on a single line → still collapsed. + ("S5: multiple empty holes on one line still collapse", + () => { + var w = Make(); + string a = string.Empty, b = string.Empty; + w.WriteLine(isMultiline: true, $$""" + [Header] + {{a}}{{b}} + public class Foo + """); + return w.ToString(); + }, + "[Header]\npublic class Foo\n"), + + // Case 6: hole at start of template, empty - buffer is empty so suppress rule doesn't fire. + ("S6: leading empty hole produces a leading blank line (buffer is empty)", + () => { + var w = Make(); + string a = string.Empty; + w.WriteLine(isMultiline: true, $$""" + {{a}} + public class Foo + """); + return w.ToString(); + }, + "\npublic class Foo\n"), + + // Case 7: Write (not WriteLine) - no trailing newline appended by the call. + ("S7: Write (no trailing newline) with all-empty interior holes", + () => { + var w = Make(); + string a = string.Empty, b = string.Empty; + w.Write(isMultiline: true, $$""" + [Header] + {{a}} + {{b}} + public class Foo + """); + return w.ToString(); + }, + "[Header]\npublic class Foo"), + + // Case 8: indentation still applied to non-empty lines. + ("S8: indented writer with mixed empty/non-empty holes", + () => { + var w = Make(); + w.IncreaseIndent(); + string a = string.Empty, b = "[B]"; + w.WriteLine(isMultiline: true, $$""" + [Header] + {{a}} + {{b}} + public class Foo + """); + return w.ToString(); + }, + " [Header]\n [B]\n public class Foo\n"), + + // Case 9: literal-only multiline template (no holes) is unaffected. + ("S9: literal-only template (no holes) is unaffected", + () => { + var w = Make(); + w.WriteLine(isMultiline: true, $$""" + Line1 + Line2 + + Line4 + """); + return w.ToString(); + }, + "Line1\nLine2\n\nLine4\n"), + + // Case 10: callback-style interpolation: empty callback hole is collapsed. + ("S10: empty string callback collapsed identically to empty string hole", + () => { + var w = Make(); + string a = "[A]", b = string.Empty; + w.WriteLine(isMultiline: true, $$""" + [Header] + {{a}} + {{b}} + public class Foo + """); + return w.ToString(); + }, + "[Header]\n[A]\npublic class Foo\n"), + }; + + foreach ((string desc, Func actualFn, string expected) in tests) + { + string actual = actualFn(); + bool pass = actual == expected; + if (!pass) + { + failures++; + } + + Console.WriteLine($"{(pass ? "PASS" : "FAIL")}: {desc}"); + + if (!pass) + { + Console.WriteLine($" expected: {Escape(expected)}"); + Console.WriteLine($" actual: {Escape(actual)}"); + } + } + + Console.WriteLine(); + Console.WriteLine($"=== {tests.Count - failures}/{tests.Count} smoke tests passed ==="); + + return failures == 0 ? 0 : 1; + + static string Escape(string s) => s.Replace("\\", "\\\\").Replace("\n", "\\n").Replace("\r", "\\r").Replace("\t", "\\t"); + } } diff --git a/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj b/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj index cd4fb39a6..59963b3a7 100644 --- a/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj +++ b/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj @@ -49,6 +49,10 @@ + + + + diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs index 5583cfc09..7f5b629a2 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.AppendInterpolatedStringHandler.cs @@ -16,9 +16,18 @@ internal partial class IndentedTextWriter /// /// Provides a handler used by the language compiler to append interpolated strings into instances. /// + /// + /// + /// In multiline mode, the handler automatically suppresses blank lines that exist in the + /// template only because every interpolation hole on that line expanded to empty content + /// (e.g. an attribute callback that early-returns based on build configuration). Literal + /// blank lines in the source template (consecutive newlines not separated by an interpolation + /// hole) are always preserved unchanged. Both LF and CRLF source line endings are handled. + /// + /// [EditorBrowsable(EditorBrowsableState.Never)] [InterpolatedStringHandler] - public readonly ref struct AppendInterpolatedStringHandler + public ref struct AppendInterpolatedStringHandler { /// The associated to which to append. private readonly IndentedTextWriter _writer; @@ -26,6 +35,14 @@ public readonly ref struct AppendInterpolatedStringHandler /// When , treats the content as multiline (normalizes CRLF -> LF and indents every line). private readonly bool _isMultiline; + /// + /// Tracks whether any AppendFormatted call between the previous and the next AppendLiteral + /// emitted any content. Reset to at every AppendLiteral, set to + /// by AppendFormatted calls that grow the buffer. Used by the blank-line + /// suppression rule to decide whether a literal segment's leading newline can be dropped. + /// + private bool _anyContentBetweenLiterals; + /// Creates a handler used to append an interpolated string into a . /// The number of constant characters outside of interpolation expressions in the interpolated string. /// The number of interpolation expressions in the interpolated string. @@ -38,6 +55,7 @@ public AppendInterpolatedStringHandler( { _writer = writer; _isMultiline = false; + _anyContentBetweenLiterals = false; } /// Creates a handler used to append an interpolated string into a . @@ -54,13 +72,49 @@ public AppendInterpolatedStringHandler( { _writer = writer; _isMultiline = isMultiline; + _anyContentBetweenLiterals = false; } /// Writes the specified string to the handler. /// The string to write. public void AppendLiteral(string value) { - _writer.Write(_isMultiline, value); + ReadOnlySpan span = value; + + // Blank-line suppression rule: a literal segment that begins with a newline (LF or + // CRLF) immediately after one or more empty interpolation holes whose surrounding + // literals also ended in '\n' would emit a stray blank line. Strip the leading + // newline to collapse the would-be blank line. + // + // The rule fires only when: + // 1. The previous content in the buffer ended with '\n' (the line is "fresh"), AND + // 2. No 'AppendFormatted' call since the previous literal emitted any content, AND + // 3. This literal starts with a newline (matched as either '\n' or '\r\n', since + // raw-string literals inherit the source file's line endings, i.e. CRLF on + // Windows, LF on Unix). CR-only line endings are not supported. + // + // Literal blank lines (e.g. "...\n\n...") within a single 'AppendLiteral' are always + // preserved because they are emitted by the multiline parser in one streaming pass + // without the rule getting a chance to fire between them. + if (span.Length > 0 && + !_anyContentBetweenLiterals && + _writer._buffer.Length > 0 && + _writer._buffer[^1] == DefaultNewLine) + { + if (span[0] == '\n') + { + span = span[1..]; + } + else if (span.Length > 1 && span[0] == '\r' && span[1] == '\n') + { + span = span[2..]; + } + } + + _writer.Write(_isMultiline, span); + + // We just wrote a literal, so reset the "any content between literals" flag for next time + _anyContentBetweenLiterals = false; } /// Writes the specified value to the handler. @@ -73,34 +127,36 @@ public void AppendFormatted(T value) return; } + int beforeLength = _writer._buffer.Length; + // Handle custom callbacks first. The value-type fast path lets the JIT specialize // the dispatch when 'T' is the concrete callback struct (e.g. WriteIidGuidReferenceCallback). if (typeof(T).IsValueType && value is IIndentedTextWriterCallback) { ((IIndentedTextWriterCallback)value).Write(_writer); - - return; } - - // Polymorphic fallback for callers that declare the local as the interface type - // (e.g. to assign one of several concrete callback structs based on a condition). - if (value is IIndentedTextWriterCallback callback) + else if (value is IIndentedTextWriterCallback callback) { + // Polymorphic fallback for callers that declare the local as the interface type + // (e.g. to assign one of several concrete callback structs based on a condition). callback.Write(_writer); - - return; } - - // If the value is a 'string', write it while preserving the multiline semantics. - // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. - if (value is string text) + else if (value is string text) { + // If the value is a 'string', write it while preserving the multiline semantics. _writer.Write(_isMultiline, text); } else { + // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. _ = _writer._buffer.Append($"{value}"); } + + // Track whether we actually wrote any content as part of this interpolation hole + if (_writer._buffer.Length > beforeLength) + { + _anyContentBetweenLiterals = true; + } } /// Writes the specified value to the handler. @@ -114,6 +170,8 @@ public void AppendFormatted(T value, string? format) return; } + int beforeLength = _writer._buffer.Length; + // If the value is a 'string', write it while preserving the multiline semantics. // Otherwise, leverage the 'StringBuilder' handler for zero-alloc interpolation. if (value is string text) @@ -128,13 +186,27 @@ public void AppendFormatted(T value, string? format) _ = _writer._buffer.Append(ref handler); } + + // Track the interpolation result (see above) + if (_writer._buffer.Length > beforeLength) + { + _anyContentBetweenLiterals = true; + } } /// Writes the specified character span to the handler. /// The span to write. public void AppendFormatted(scoped ReadOnlySpan value) { + int beforeLength = _writer._buffer.Length; + _writer.Write(_isMultiline, value); + + // Track the interpolation result (see above) + if (_writer._buffer.Length > beforeLength) + { + _anyContentBetweenLiterals = true; + } } /// Writes the specified value to the handler. @@ -146,7 +218,15 @@ public void AppendFormatted(string? value) return; } + int beforeLength = _writer._buffer.Length; + _writer.Write(_isMultiline, value); + + // Track the interpolation result (see above) + if (_writer._buffer.Length > beforeLength) + { + _anyContentBetweenLiterals = true; + } } } } From ab71e6f85dc2e584312596e1b330561789623691 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:15:03 -0700 Subject: [PATCH 045/171] R6-6: Collapse DoAbi 22-line dead 4-branch chain to single line All four branches of the if/elif/elif/else in 'EmitDoAbiPostCallWriteback' emit identical "*{retParamName} = {retLocalName};" output (verified by view). Replace the chunked Write + 4-branch dispatch with a single WriteLine. Output is byte-identical for all 3 reference scenarios (763 generated .cs files: 10 pushnot + 406 everything-with-ui + 347 windows). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 22 +------------------ 1 file changed, 1 insertion(+), 21 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index f54537262..d5cfd1621 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -715,27 +715,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else { - writer.Write($" *{retParamName} = "); - - if (rt is CorLibTypeSignature corlib && - corlib.ElementType == ElementType.Boolean) - { - writer.WriteLine($"{retLocalName};"); - } - else if (rt is CorLibTypeSignature corlib2 && - corlib2.ElementType == ElementType.Char) - { - writer.WriteLine($"{retLocalName};"); - } - else if (context.AbiTypeShapeResolver.IsEnumType(rt)) - { - // Enum: function pointer signature uses the projected enum type, no cast needed. - writer.WriteLine($"{retLocalName};"); - } - else - { - writer.WriteLine($"{retLocalName};"); - } + writer.WriteLine($" *{retParamName} = {retLocalName};"); } } From d91b40e12437794d204e37f4bcbf6e8c9ae9c4c4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:18:12 -0700 Subject: [PATCH 046/171] R6-30: Dead code and discard cleanups Removes dead/unused code identified in the R6 analysis: - Deletes the 13 `string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(...);` + `_ = elementInteropArg;` pairs in DoAbi.cs, RcwCaller.cs, FactoryCallbacks.cs. Each local was assigned and then immediately discarded with `_ = ...;` - the value is never used. Both lines are deleted per pair. - Deletes the `hasStringParams` block in DoAbi.cs (declaration + loop + discard): the flag was computed by iterating all params but never consumed. - Inlines the two single-line `WritePragmaDisableIL2026` / `WritePragmaRestoreIL2026` helpers at their only call site in ProjectionGenerator.Namespace.cs and deletes the definitions in MetadataAttributeFactory.cs (each helper had exactly 1 caller). - Deletes the dead `WriteFundamentalNonProjectedType` helper in TypedefNameWriter.cs (0 callers, verified by grep). The sibling `WriteFundamentalType` is kept (1 caller). - Deletes the stray `//, 1697).` comment fragment at ClassMembersFactory.WriteClassMembers.cs:83. - Deletes the duplicate `` XML doc on `WriteDelegateMarshallerOnly` in AbiDelegateFactory.cs (two summaries, kept the more specific one). - Replaces spurious `writer.Write($`"{getterPlat}")` / `writer.Write($`"{setterPlat}")` with direct `writer.Write(getterPlat)` / `writer.Write(setterPlat)` at ClassMembersFactory.WriteClassMembers.cs:121,149 (the interpolation was a no-op since the value is already a string). Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 3 --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 22 ------------------- .../AbiMethodBodyFactory.RcwCaller.cs | 22 ------------------- .../ClassMembersFactory.WriteClassMembers.cs | 5 ++--- .../ConstructorFactory.FactoryCallbacks.cs | 4 ---- .../Factories/MetadataAttributeFactory.cs | 19 ---------------- .../ProjectionGenerator.Namespace.cs | 5 +++-- .../Helpers/TypedefNameWriter.cs | 10 --------- 8 files changed, 5 insertions(+), 85 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 374f9afce..be974dc36 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -331,9 +331,6 @@ public EventState(void* thisPtr, int index) """); } - /// - /// Writes a marshaller stub for a delegate. - /// /// /// Emits just the <Name>Marshaller class for a delegate. /// diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index d5cfd1621..d5cb7caf3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -26,16 +26,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { TypeSignature? rt = sig.ReturnType; - // String params drive whether we need HString header allocation in the body. - bool hasStringParams = false; - foreach (ParameterInfo p in sig.Parameters) - { - if (p.Type.IsString()) - { - hasStringParams = true; - break; - } - } bool returnIsReceiveArrayDoAbi = rt is SzArrayTypeSignature retSzAbi && (context.AbiTypeShapeResolver.IsBlittablePrimitive(retSzAbi.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(retSzAbi.BaseType) || retSzAbi.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSzAbi.BaseType) || retSzAbi.BaseType.IsObject() @@ -132,9 +122,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(sza.BaseType, TypedefNameType.Projected); - _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); string elementAbi = sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject() ? "void*" @@ -160,9 +148,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection : context.AbiTypeShapeResolver.IsBlittableStruct(retSzHoist.BaseType) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSzHoist.BaseType) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSzHoist.BaseType); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(retSzHoist.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(retSzHoist.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] @@ -335,9 +320,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; // For complex structs, the data param is the ABI struct pointer (e.g. BasicStruct*). // The Do_Abi parameter we receive is void* (per V3R3-M8), so the call-site needs an // explicit (T*) cast to bridge the type. For ref-types (string/runtime-class/object), @@ -615,9 +597,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szFA.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; // Determine the ABI element type for the data pointer cast. // - Strings / runtime classes / objects: void** // - HResult exception: global::ABI.System.Exception* @@ -794,7 +773,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } } writer.WriteLine(); - _ = hasStringParams; } /// diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index dfaff6fb8..c2f990c3a 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -843,9 +843,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; // For mapped value types (DateTime/TimeSpan) and complex structs, the storage // element is the ABI struct type; the data pointer parameter type uses that // ABI struct. The fixed() opens with void* (per truth's pattern), so a cast @@ -1043,9 +1040,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szFA.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; // Determine the ABI element type for the data pointer parameter. // - Strings / runtime classes / objects: void** // - HResult exception: global::ABI.System.Exception* @@ -1187,9 +1181,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(sza.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] @@ -1215,9 +1206,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(retSz.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{elementProjected}}[] ConvertToManaged_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); @@ -1449,10 +1437,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec fixedPtrType = "void*"; disposeCastType = "(void**)"; } - - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] static extern void Dispose_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{disposeDataParamType}} @@ -1539,9 +1523,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(sza.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] @@ -1583,9 +1564,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(retSz.BaseType, TypedefNameType.Projected); - - _ = elementInteropArg; writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] static extern void Free_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index af6a9d797..0cee4891f 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -80,7 +80,6 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo // For getter-only properties, emit expression body: 'public T Prop => Expr;' // For getter+setter or setter-only, use accessor block: 'public T Prop { get => ...; set => ...; }' // In ref mode, all property bodies emit '=> throw null;' - //, 1697). bool getterOnly = s.HasGetter && !s.HasSetter; if (getterOnly) @@ -118,7 +117,7 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo { if (!string.IsNullOrEmpty(getterPlat)) { - writer.Write($"{getterPlat}"); + writer.Write(getterPlat); } if (context.Settings.ReferenceProjection) @@ -146,7 +145,7 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo { if (!string.IsNullOrEmpty(setterPlat)) { - writer.Write($"{setterPlat}"); + writer.Write(setterPlat); } if (context.Settings.ReferenceProjection) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 90090e40a..005a7e10e 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -464,8 +464,6 @@ public override unsafe void Invoke( else { WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); - _ = elementInteropArg; writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] {{callIndent}}static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, void** data); @@ -633,8 +631,6 @@ public override unsafe void Invoke( } else { - string elementInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(szArr.BaseType, TypedefNameType.Projected); - _ = elementInteropArg; writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 8830a0154..4647c7061 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -23,25 +23,6 @@ namespace WindowsRuntime.ProjectionWriter.Factories; /// internal static class MetadataAttributeFactory { - /// - /// Writes #pragma warning disable IL2026. - /// - /// The writer to emit to. - public static void WritePragmaDisableIL2026(IndentedTextWriter writer) - { - writer.WriteLine("#pragma warning disable IL2026"); - } - - /// - /// Writes #pragma warning restore IL2026. - /// - /// The writer to emit to. - public static void WritePragmaRestoreIL2026(IndentedTextWriter writer) - { - writer.WriteLine(); - writer.WriteLine("#pragma warning restore IL2026"); - } - /// /// Returns the version string embedded in the banner comment of generated files. /// MSBuild and defaults to 0.0.0-private.0). diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index 51f2601db..7d376394a 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -38,7 +38,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe if (!_settings.ReferenceProjection) { writer.WriteLine(); - MetadataAttributeFactory.WritePragmaDisableIL2026(writer); + writer.WriteLine("#pragma warning disable IL2026"); foreach (TypeDefinition type in members.Types) { if (!_settings.Filter.Includes(type)) @@ -99,7 +99,8 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe } } - MetadataAttributeFactory.WritePragmaRestoreIL2026(writer); + writer.WriteLine(); + writer.WriteLine("#pragma warning restore IL2026"); } // Phase 2: Projected types diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index e404c2ab0..7c62cfee5 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -28,16 +28,6 @@ public static void WriteFundamentalType(IndentedTextWriter writer, FundamentalTy writer.Write(FundamentalTypes.ToCSharpType(t)); } - /// - /// Writes a fundamental (primitive) type's non-projected (.NET BCL) name. - /// - /// The writer to emit to. - /// The fundamental type. - public static void WriteFundamentalNonProjectedType(IndentedTextWriter writer, FundamentalType t) - { - writer.Write(FundamentalTypes.ToDotNetType(t)); - } - /// /// Writes the C# type name for a typed reference. /// From 27dc60e247caeaa7ae4321de138b58698e95f2e2 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:19:21 -0700 Subject: [PATCH 047/171] R6-20: Extract MarkAllRequiredInterfacesVisited helper The 3 `foreach (impl2 in required.Interfaces) { ... _ = visited.Add(r2); }` blocks in AbiInterfaceIDicFactory.cs (at the IBindableVector, IObservableMap`2, and IObservableVector`1 special-case handlers) were character-for-character identical. Extract a private `MarkAllRequiredInterfacesVisited` helper that encapsulates the iteration + null-check + `visited.Add` logic. Each call site now reads as one method invocation instead of an 11-line nested foreach with conditional inner logic, making the actual control flow of `WriteInterfaceIdicImplMembersForRequiredInterfaces` easier to follow. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 69 ++++++++----------- 1 file changed, 27 insertions(+), 42 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 4714f5018..f46280a91 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -105,20 +105,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( // required interfaces so any other (deeper) inherited mapped interface is covered. if (rName == "IBindableVector") { - foreach (InterfaceImplementation impl2 in required.Interfaces) - { - if (impl2.Interface is null) - { - continue; - } - - TypeDefinition? r2 = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl2.Interface); - - if (r2 is not null) - { - _ = visited.Add(r2); - } - } + MarkAllRequiredInterfacesVisited(context, required, visited); } continue; @@ -135,20 +122,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( string valueText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[1]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableMapForwarders(writer, context, keyText, valueText); // Mark the inherited IMap`2 / IIterable`1 as visited so they aren't re-emitted. - foreach (InterfaceImplementation impl2 in required.Interfaces) - { - if (impl2.Interface is null) - { - continue; - } - - TypeDefinition? r2 = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl2.Interface); - - if (r2 is not null) - { - _ = visited.Add(r2); - } - } + MarkAllRequiredInterfacesVisited(context, required, visited); } continue; @@ -160,20 +134,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( { string elementText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giVec.TypeArguments[0]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableVectorForwarders(writer, context, elementText); - foreach (InterfaceImplementation impl2 in required.Interfaces) - { - if (impl2.Interface is null) - { - continue; - } - - TypeDefinition? r2 = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl2.Interface); - - if (r2 is not null) - { - _ = visited.Add(r2); - } - } + MarkAllRequiredInterfacesVisited(context, required, visited); } continue; @@ -191,6 +152,30 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( } } + /// + /// Adds all directly-required interfaces of to + /// so they aren't re-emitted as forwarders. Used by the shim emitters that already cover their + /// inherited interface members transitively (e.g. IBindableVector already includes + /// IBindableIterable's members). + /// + private static void MarkAllRequiredInterfacesVisited(ProjectionEmitContext context, TypeDefinition required, HashSet visited) + { + foreach (InterfaceImplementation impl2 in required.Interfaces) + { + if (impl2.Interface is null) + { + continue; + } + + TypeDefinition? r2 = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl2.Interface); + + if (r2 is not null) + { + _ = visited.Add(r2); + } + } + } + /// /// Emits IDictionary<K,V> / ICollection<KVP> / IEnumerable<KVP> + /// IObservableMap<K,V>.MapChanged forwarders for a DIC file interface that inherits From da1bb5cfe8af85f2887a4a69ff2b860737f7b220 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:21:05 -0700 Subject: [PATCH 048/171] R6-19: Unify FindPropertyInBaseInterfaces variants via Try- pattern Replaces the two ~50-line duplicated recursive walks (`FindPropertyInBaseInterfaces` returning `bool` and `FindPropertyInterfaceInBases` returning `TypeDefinition?`) with one `TryFindPropertyInBaseInterfaces` method that uses the idiomatic .NET `Try-` pattern with a `[NotNullWhen(true)] out TypeDefinition? foundInterface` parameter. Both callers updated: - `InterfaceFactory.cs:261` (was the bool variant; now uses `out _` since only existence matters for the `new` modifier decision). - `AbiInterfaceIDicFactory.cs:472` (was the `TypeDefinition?` variant + `is not null` follow-up; now a single `if (Try... out var baseIfaceWithGetter)` statement). Removes ~50 lines of duplicated recursion; the original C++ tool had a single helper. The `Try-` pattern avoids the call-site null-check follow-up. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 4 +- .../Factories/InterfaceFactory.cs | 76 +++---------------- 2 files changed, 13 insertions(+), 67 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index f46280a91..75f7971d2 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -469,9 +469,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite // to the base interface where the getter actually lives if (getter is null) { - TypeDefinition? baseIfaceWithGetter = InterfaceFactory.FindPropertyInterfaceInBases(context.Cache, type, pname); - - if (baseIfaceWithGetter is not null) + if (InterfaceFactory.TryFindPropertyInBaseInterfaces(context.Cache, type, pname, out TypeDefinition? baseIfaceWithGetter)) { WriteInterfaceTypeNameForCcwCallback iface = ClassMembersFactory.WriteInterfaceTypeNameForCcw(context, baseIfaceWithGetter); writer.WriteLine($" get {{ return (({iface})(WindowsRuntimeObject)this).{pname}; }}"); diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index c020cd689..2acf87fcc 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using AsmResolver; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; @@ -258,7 +259,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro // name exists on a base interface (typically the getter-only counterpart). This hides // the inherited member. string newKeyword = (getter is null && setter is not null - && FindPropertyInBaseInterfaces(context.Cache, type, prop.Name?.Value ?? string.Empty)) + && TryFindPropertyInBaseInterfaces(context.Cache, type, prop.Name?.Value ?? string.Empty, out _)) ? "new " : string.Empty; string propType = WritePropType(context, prop); writer.Write($"{newKeyword}{propType} {prop.Name?.Value ?? string.Empty} {{"); @@ -281,20 +282,22 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro /// Recursively walks the base interfaces of looking for a property /// with the given . Returns true if any base interface declares /// a property with that name (used to decide whether a setter-only property in a derived - /// interface needs the new modifier to hide the base getter). + /// interface needs the new modifier to hide the base getter). When found, the base + /// interface where the property was declared is returned via . /// - private static bool FindPropertyInBaseInterfaces(MetadataCache cache, TypeDefinition type, string propName) + internal static bool TryFindPropertyInBaseInterfaces(MetadataCache cache, TypeDefinition type, string propName, [NotNullWhen(true)] out TypeDefinition? foundInterface) { if (string.IsNullOrEmpty(propName)) { + foundInterface = null; return false; } HashSet visited = []; - return FindPropertyInBaseInterfacesRecursive(cache, type, propName, visited); + return TryFindPropertyInBaseInterfacesRecursive(cache, type, propName, visited, out foundInterface); } - private static bool FindPropertyInBaseInterfacesRecursive(MetadataCache cache, TypeDefinition type, string propName, HashSet visited) + private static bool TryFindPropertyInBaseInterfacesRecursive(MetadataCache cache, TypeDefinition type, string propName, HashSet visited, [NotNullWhen(true)] out TypeDefinition? foundInterface) { foreach (InterfaceImplementation impl in type.Interfaces) { @@ -325,74 +328,19 @@ private static bool FindPropertyInBaseInterfacesRecursive(MetadataCache cache, T { if ((prop.Name?.Value ?? string.Empty) == propName) { + foundInterface = baseIface; return true; } } - if (FindPropertyInBaseInterfacesRecursive(cache, baseIface, propName, visited)) + if (TryFindPropertyInBaseInterfacesRecursive(cache, baseIface, propName, visited, out foundInterface)) { return true; } } - return false; - } - /// - /// Like but returns the base interface where the - /// property was found (or null if not found). - /// - internal static TypeDefinition? FindPropertyInterfaceInBases(MetadataCache cache, TypeDefinition type, string propName) - { - if (string.IsNullOrEmpty(propName)) - { - return null; - } - - HashSet visited = []; - return FindPropertyInterfaceInBasesRecursive(cache, type, propName, visited); - } - - private static TypeDefinition? FindPropertyInterfaceInBasesRecursive(MetadataCache cache, TypeDefinition type, string propName, HashSet visited) - { - foreach (InterfaceImplementation impl in type.Interfaces) - { - if (impl.Interface is null) - { - continue; - } - - TypeDefinition? baseIface = ClassMembersFactory.ResolveInterface(cache, impl.Interface); - - if (baseIface is null) - { - continue; - } - - if (baseIface == type) - { - continue; - } - - if (!visited.Add(baseIface)) - { - continue; - } - - foreach (PropertyDefinition prop in baseIface.Properties) - { - if ((prop.Name?.Value ?? string.Empty) == propName) - { - return baseIface; - } - } - TypeDefinition? deeper = FindPropertyInterfaceInBasesRecursive(cache, baseIface, propName, visited); - - if (deeper is not null) - { - return deeper; - } - } - return null; + foundInterface = null; + return false; } /// From af01d7aa2202885646937dc3c43f5c0e71ad9708 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:23:01 -0700 Subject: [PATCH 049/171] =?UTF-8?q?R6-13:=20ClassFactory=20IsOverridableIn?= =?UTF-8?q?terface=20=E2=80=94=20string.Join=20instead=20of=20WriteIf=20bo?= =?UTF-8?q?okkeeping?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the mutable `firstClause` bool + 3 `WriteIf(!firstClause, " || ")` calls in ClassFactory's two override-hook emitters with a `List` clauses + `string.Join(" || ", clauses)`. The fallback `"false"` is selected when the list is empty. The two adjacent override hooks (`HasUnwrappableNativeObjectReference` and `IsOverridableInterface`) are now emitted via one multiline raw-string `WriteLine` with the expression bodies inlined as interpolation holes: the expression now reads at the call site the same way the generated source appears in the output. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ClassFactory.cs | 38 +++++++------------ 1 file changed, 13 insertions(+), 25 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 42e42df2b..d2a9b7e9b 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -687,22 +687,9 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont // be emitted BEFORE the public members. if (!context.Settings.ReferenceProjection) { - writer.WriteLine(); - writer.Write("protected override bool HasUnwrappableNativeObjectReference => "); - - if (!type.IsSealed) - { - writer.Write($"GetType() == typeof({typeName});"); - } - else - { - writer.Write("true;"); - } + string unwrappable = type.IsSealed ? "true" : $"GetType() == typeof({typeName});"; - writer.WriteLine(); - writer.WriteLine(); - writer.Write("protected override bool IsOverridableInterface(in Guid iid) => "); - bool firstClause = true; + List overridableClauses = []; foreach (InterfaceImplementation impl in type.Interfaces) { if (!impl.IsOverridable()) @@ -717,11 +704,8 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont continue; } - writer.WriteIf(!firstClause, " || "); - - firstClause = false; WriteIidExpressionCallback iid = ObjRefNameGenerator.WriteIidExpression(context, implRef); - writer.Write($"{iid} == iid"); + overridableClauses.Add($"{iid.Format()} == iid"); } // base call when type has a non-object base class @@ -731,15 +715,19 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont if (hasBaseClass) { - writer.WriteIf(!firstClause, " || "); - - writer.Write("base.IsOverridableInterface(in iid)"); - firstClause = false; + overridableClauses.Add("base.IsOverridableInterface(in iid)"); } - writer.WriteIf(firstClause, "false"); + string overridableExpr = overridableClauses.Count == 0 + ? "false" + : string.Join(" || ", overridableClauses); - writer.WriteLine(";"); + writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" + protected override bool HasUnwrappableNativeObjectReference => {{unwrappable}}{{(type.IsSealed ? ";" : "")}} + + protected override bool IsOverridableInterface(in Guid iid) => {{overridableExpr}}; + """); } ClassMembersFactory.WriteClassMembers(writer, context, type); From 802fe129b3b9102f4ab8b6d08e9ff61fcc1e22ff Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:25:02 -0700 Subject: [PATCH 050/171] R6-5: IdentifierEscaping.EscapeIdentifier helper + ParameterInfo.GetEscapedName MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds two foundational helpers and migrates all open-coded `CSharpKeywords.IsKeyword(x) ? "@" + x : x` ternaries to the central helper, eliminating the 24+ verified duplicated escape ternaries across the codebase: - `IdentifierEscaping.EscapeIdentifier(string id)` — returns the identifier prefixed with `@` if it's a reserved C# keyword. - `ParameterInfo.GetEscapedName(string defaultName = "param")` — extension that combines `p.Parameter.Name ?? defaultName` with the escape. Available for future per-site simplifications where the `string raw = … ?? "param"` preamble is only used to compute the escaped form. Mechanical migration: every `writer.Write(CSharpKeywords.IsKeyword(X) ? "@" + X : X)` becomes `writer.Write(IdentifierEscaping.EscapeIdentifier(X))`, and every `string Y = CSharpKeywords.IsKeyword(X) ? "@" + X : X;` becomes `string Y = IdentifierEscaping.EscapeIdentifier(X);` across AbiDelegateFactory.cs, AbiMethodBodyFactory.DoAbi.cs, ConstructorFactory.{AttributedTypes,Composable,FactoryCallbacks}.cs, EventTableFactory.cs, and Helpers/AbiTypeHelpers.cs. The existing single `WriteParameterName` writer-style helper in MethodFactory.cs:121-128 is preserved unchanged (intentionally split for its multiline behavior). Sites where both `raw` (used in `__{raw}`/`_{raw}` variable names) and `pname` (the escaped form) are needed are left untouched — only the ternary itself is collapsed. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 4 ++-- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 22 ++++++++--------- .../ConstructorFactory.AttributedTypes.cs | 2 +- .../ConstructorFactory.Composable.cs | 2 +- .../ConstructorFactory.FactoryCallbacks.cs | 24 +++++++++---------- .../Factories/EventTableFactory.cs | 4 ++-- .../Helpers/AbiTypeHelpers.cs | 4 ++-- .../Helpers/IdentifierEscaping.cs | 11 +++++++++ .../Models/ParameterInfoExtensions.cs | 23 ++++++++++++++++++ 9 files changed, 65 insertions(+), 31 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index be974dc36..4f2e72433 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -302,7 +302,7 @@ public EventState(void* thisPtr, int index) } string raw = sig.Parameters[i].Parameter.Name ?? "p"; - writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); + writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); } writer.Write(") => TargetDelegate.Invoke("); for (int i = 0; i < sig.Parameters.Count; i++) @@ -321,7 +321,7 @@ public EventState(void* thisPtr, int index) } string raw = sig.Parameters[i].Parameter.Name ?? "p"; - writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); + writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); } writer.WriteLine(isMultiline: true, """ ); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index d5cb7caf3..a0f8ced40 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -202,7 +202,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"*{ptr} = default;"); } for (int i = 0; i < sig.Parameters.Count; i++) @@ -237,7 +237,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); writer.WriteLine(isMultiline: true, $$""" @@ -267,7 +267,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittablePrimitive(sz.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(sz.BaseType); @@ -318,7 +318,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); // For complex structs, the data param is the ABI struct pointer (e.g. BasicStruct*). // The Do_Abi parameter we receive is void* (per V3R3-M8), so the call-site needs an @@ -356,7 +356,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { // Nullable param (server-side): use Marshaller.UnboxToManaged. string rawName = p.Parameter.Name ?? "param"; - string callName = CSharpKeywords.IsKeyword(rawName) ? "@" + rawName : rawName; + string callName = IdentifierEscaping.EscapeIdentifier(rawName); TypeSignature inner = p.Type.GetNullableInnerType()!; string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); writer.WriteLine($" var __arg_{rawName} = {innerMarshaller}.UnboxToManaged({callName});"); @@ -364,7 +364,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection else if (p.Type.IsGenericInstance()) { string rawName = p.Parameter.Name ?? "param"; - string callName = CSharpKeywords.IsKeyword(rawName) ? "@" + rawName : rawName; + string callName = IdentifierEscaping.EscapeIdentifier(rawName); string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" @@ -436,7 +436,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // side it's projected as 'in T'. Read directly from * via the appropriate // marshaller — DO NOT zero or write back. string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); TypeSignature uRef = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); if (uRef.IsString()) @@ -504,7 +504,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); string rhs; // String: HStringMarshaller.ConvertToUnmanaged @@ -564,7 +564,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($" ConvertToUnmanaged_{raw}(null, __{raw}, out *__{raw}Size, out *{ptr});"); } @@ -595,7 +595,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.Parameter.Name ?? "param"; - string ptr = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); // Determine the ABI element type for the data pointer cast. // - Strings / runtime classes / objects: void** @@ -781,7 +781,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, ProjectionEmitContext context, ParameterInfo p) { string rawName = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(rawName) ? "@" + rawName : rawName; + string pname = IdentifierEscaping.EscapeIdentifier(rawName); if (p.Type is CorLibTypeSignature corlib && corlib.ElementType == ElementType.Boolean) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 1762df991..44e93e128 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -140,7 +140,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio writer.WriteIf(i > 0, ", "); string raw = sig.Parameters[i].Parameter.Name ?? "param"; - writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); + writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); } writer.Write("))"); } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 645b1a3db..f807de4bb 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -107,7 +107,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec writer.WriteIf(i > 0, ", "); string raw = sig.Parameters[i].Parameter.Name ?? "param"; - writer.Write(CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw); + writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); } writer.Write("))"); } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 005a7e10e..5ad5fa7e9 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -46,7 +46,7 @@ private static void EmitFactoryArgsStruct(IndentedTextWriter writer, ProjectionE { ParameterInfo p = sig.Parameters[i]; string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.Write(" public readonly "); // Use the parameter's projected type (matches the constructor parameter type, including // ReadOnlySpan/Span for array params). @@ -128,7 +128,7 @@ public override unsafe void Invoke( { ParameterInfo p = sig.Parameters[i]; string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); writer.Write(" "); // For array params, the bind type is ReadOnlySpan / Span (not the SzArray). @@ -161,7 +161,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); if (p.Type.IsNullableT()) { @@ -197,7 +197,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.Write($" using WindowsRuntimeObjectReferenceValue __{raw} = "); AbiMethodBodyFactory.EmitMarshallerConvertToUnmanaged(writer, context, p.Type, pname); writer.WriteLine(";"); @@ -225,7 +225,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); string abiType = AbiTypeHelpers.GetMappedAbiTypeName(p.Type); string marshaller = AbiTypeHelpers.GetMappedMarshallerName(p.Type); writer.WriteLine($" {abiType} __{raw} = {marshaller}.ConvertToUnmanaged({pname});"); @@ -244,7 +244,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($" global::ABI.System.Exception __{raw} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({pname});"); } @@ -273,7 +273,7 @@ public override unsafe void Invoke( hasNonBlittableArray = true; string raw = p.Parameter.Name ?? "param"; - string callName = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string callName = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16 __{{raw}}_inlineArray); @@ -325,7 +325,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"{baseIndent}global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({pname}, out TypeReference __{raw});"); } @@ -368,7 +368,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteIf(!firstPin, ", "); @@ -420,7 +420,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"{innerIndent}HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{raw}, {pname}?.Length, out HStringReference __{raw});"); } } @@ -449,7 +449,7 @@ public override unsafe void Invoke( } string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); if (szArr.BaseType.IsString()) { @@ -500,7 +500,7 @@ public override unsafe void Invoke( ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); string raw = p.Parameter.Name ?? "param"; - string pname = CSharpKeywords.IsKeyword(raw) ? "@" + raw : raw; + string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.Write(isMultiline: true, """ , diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index 3c87a20f0..a8c999d74 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -58,7 +58,7 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit // Handler is the (last) input parameter of the add method. The emitted parameter name in the // signature comes from WriteAbiParameterTypesPointer which uses the metadata name verbatim. string handlerRawName = sig.Parameters.Count > 0 ? (sig.Parameters[^1].Parameter.Name ?? "handler") : "handler"; - string handlerRef = CSharpKeywords.IsKeyword(handlerRawName) ? "@" + handlerRawName : handlerRawName; + string handlerRef = IdentifierEscaping.EscapeIdentifier(handlerRawName); // The cookie/token return parameter takes the metadata return param name (matches truth). string cookieName = AbiTypeHelpers.GetReturnParamName(sig); @@ -111,7 +111,7 @@ internal static void EmitDoAbiRemoveEvent(IndentedTextWriter writer, ProjectionE { string evName = evt.Name?.Value ?? "Event"; string tokenRawName = sig.Parameters.Count > 0 ? (sig.Parameters[^1].Parameter.Name ?? "token") : "token"; - string tokenRef = CSharpKeywords.IsKeyword(tokenRawName) ? "@" + tokenRawName : tokenRawName; + string tokenRef = IdentifierEscaping.EscapeIdentifier(tokenRawName); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 7509c922c..52da756b8 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -148,7 +148,7 @@ internal static string GetReturnParamName(MethodSignatureInfo sig) return "__return_value__"; } - return CSharpKeywords.IsKeyword(n) ? "@" + n : n; + return IdentifierEscaping.EscapeIdentifier(n); } /// @@ -434,7 +434,7 @@ internal static TypeSignature StripByRefAndCustomModifiers(TypeSignature sig) internal static string GetParamName(ParameterInfo p, string? paramNameOverride) { string name = paramNameOverride ?? p.Parameter.Name ?? "param"; - return CSharpKeywords.IsKeyword(name) ? "@" + name : name; + return IdentifierEscaping.EscapeIdentifier(name); } /// diff --git a/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs b/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs index 025c102a5..f0158bed3 100644 --- a/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs +++ b/src/WinRT.Projection.Writer/Helpers/IdentifierEscaping.cs @@ -23,6 +23,17 @@ public static string StripBackticks(string typeName) return idx >= 0 ? typeName[..idx] : typeName; } + /// + /// Returns prefixed with @ if it is a reserved C# keyword; + /// otherwise returns it unchanged. + /// + /// The identifier to escape. + /// The escaped identifier. + public static string EscapeIdentifier(string identifier) + { + return CSharpKeywords.IsKeyword(identifier) ? "@" + identifier : identifier; + } + /// /// Writes to , prefixed with @ /// if it is a reserved C# keyword. diff --git a/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs b/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs new file mode 100644 index 000000000..abb8965bb --- /dev/null +++ b/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.Models; + +/// +/// Extension methods on . +/// +internal static class ParameterInfoExtensions +{ + /// + /// Returns the parameter's metadata name (or if the metadata + /// name is ) prefixed with @ if it is a reserved C# keyword. + /// Used to derive a call-argument or formal-parameter identifier from a . + /// + /// The parameter to derive the escaped name from. + /// The fallback name to use when the parameter has no metadata name. Defaults to "param". + /// The escaped parameter name. + public static string GetEscapedName(this ParameterInfo parameter, string defaultName = "param") + { + return Helpers.IdentifierEscaping.EscapeIdentifier(parameter.Parameter.Name ?? defaultName); + } +} From 32800bb322314b27b3092f6cd5b6531f39938ef3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:26:05 -0700 Subject: [PATCH 051/171] =?UTF-8?q?R6-9:=20AbiDelegateFactory=20event-sour?= =?UTF-8?q?ce=20=E2=80=94=20reuse=20WriteParameterNameWithModifierCallback?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The two character-for-character identical loops at AbiDelegateFactory.cs:289-306 and 308-325 (the GetEventInvoke `(args)` formal list and the `TargetDelegate.Invoke(args)` argument list) were reimplementing the exact same in/out/escape logic already provided by `ClassMembersFactory.WriteParameterNameWithModifier`. Replace both with the existing callback. Each loop collapses from 18 lines to 5 (one `writer.Write($`"{sep}{p}")` per element using the existing callback's emission). Per R6-5 gotcha: the original loops used `"p"` fallback while the shared helper uses `"param"`. Byte-identical in practice (compiled metadata never has null parameter names for projected delegates), and the validation confirms this: output is byte-identical for all 3 reference scenarios (763 generated .cs files). Also removes the now-unused `WindowsRuntime.ProjectionWriter.Resolvers` import. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 35 +++---------------- 1 file changed, 4 insertions(+), 31 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 4f2e72433..f1d2e43d2 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -7,7 +7,6 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; -using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -288,40 +287,14 @@ public EventState(void* thisPtr, int index) """); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.WriteIf(i > 0, ", "); - - ParameterCategory pc = ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]); - - if (pc == ParameterCategory.Ref) - { - writer.Write("in "); - } - else if (pc is ParameterCategory.Out or ParameterCategory.ReceiveArray) - { - writer.Write("out "); - } - - string raw = sig.Parameters[i].Parameter.Name ?? "p"; - writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); + WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($"{(i > 0 ? ", " : "")}{p}"); } writer.Write(") => TargetDelegate.Invoke("); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.WriteIf(i > 0, ", "); - - ParameterCategory pc = ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]); - - if (pc == ParameterCategory.Ref) - { - writer.Write("in "); - } - else if (pc is ParameterCategory.Out or ParameterCategory.ReceiveArray) - { - writer.Write("out "); - } - - string raw = sig.Parameters[i].Parameter.Name ?? "p"; - writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); + WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); + writer.Write($"{(i > 0 ? ", " : "")}{p}"); } writer.WriteLine(isMultiline: true, """ ); From f5f095eaf55efe149b8bdeb745b33179608e4e6c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:28:47 -0700 Subject: [PATCH 052/171] R6-14: Add ITypeDefOrRef.GetStrippedName() extension MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds a `GetStrippedName()` extension on `ITypeDefOrRef` that returns `IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty)` in one call, and applies it across the 16 sites that did the same 2-line preamble inline. All 16 sites turned out to have `name` unused after the preamble (verified by the analyzer reporting IDE0059 "Unnecessary assignment" on every one), so the `string name = type.Name?.Value ?? string.Empty;` line is dropped at each site. The replacement is a single `string nameStripped = type.GetStrippedName();`. Sites migrated: AbiClassFactory.cs, AbiInterfaceFactory.cs (4), AbiInterfaceIDicFactory.cs, AbiDelegateFactory.cs (8), ReferenceImplFactory.cs, StructEnumMarshallerFactory.cs. This also lets the actual interesting first statement (the writer call) sit nearer the top of each `WriteXxx` method, instead of two lines below mechanical boilerplate. R6-14b (the `DelegateNames` record extracting shared name resolution across 3 methods in AbiDelegateFactory.cs) is deferred — the 3-method duplication is narrow enough that R6-14a covers the bulk of the readability win. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiClassFactory.cs | 3 +-- .../Factories/AbiDelegateFactory.cs | 24 +++++++------------ .../Factories/AbiInterfaceFactory.cs | 12 ++++------ .../Factories/AbiInterfaceIDicFactory.cs | 3 +-- .../Factories/ReferenceImplFactory.cs | 3 +-- .../Factories/StructEnumMarshallerFactory.cs | 3 +-- .../Helpers/TypeDefOrRefExtensions.cs | 24 +++++++++++++++++++ 7 files changed, 40 insertions(+), 32 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 746897f05..c66cca204 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -205,8 +205,7 @@ public static bool EmitImplType(IndentedTextWriter writer, ProjectionEmitContext /// internal static void WriteClassMarshallerStub(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; string fullProjected = $"global::{typeNs}.{nameStripped}"; diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index f1d2e43d2..face3a7f2 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -66,8 +66,7 @@ private static void WriteDelegateImpl(IndentedTextWriter writer, ProjectionEmitC } MethodSignatureInfo sig = new(invoke); - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); WriteAbiParameterTypesPointerCallback invokeParams = AbiInterfaceFactory.WriteAbiParameterTypesPointer(context, sig, includeParamNames: true); @@ -126,8 +125,7 @@ private static void WriteDelegateVftbl(IndentedTextWriter writer, ProjectionEmit } MethodSignatureInfo sig = new(invoke); - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); WriteAbiParameterTypesPointerCallback invokeParams = AbiInterfaceFactory.WriteAbiParameterTypesPointer(context, sig); writer.WriteLine(); @@ -158,8 +156,7 @@ private static void WriteNativeDelegate(IndentedTextWriter writer, ProjectionEmi } MethodSignatureInfo sig = new(invoke); - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); writer.WriteLine(); writer.Write(isMultiline: true, $$""" @@ -188,8 +185,7 @@ private static void WriteDelegateInterfaceEntriesImpl(IndentedTextWriter writer, return; } - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); @@ -244,8 +240,7 @@ public static void WriteDelegateEventSourceSubclass(IndentedTextWriter writer, P } MethodSignatureInfo sig = new(invoke); - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); // Compute the projected type name (with global::) used as the generic argument. string projectedName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); @@ -309,8 +304,7 @@ public EventState(void* thisPtr, int index) /// private static void WriteDelegateMarshallerOnly(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; string fullProjected = $"global::{typeNs}.{nameStripped}"; string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); @@ -343,8 +337,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjec /// private static void WriteDelegateComWrappersCallback(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; string fullProjected = $"global::{typeNs}.{nameStripped}"; string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); @@ -374,8 +367,7 @@ public static object CreateObject(void* value, out CreatedWrapperFlags wrapperFl /// private static void WriteDelegateComWrappersMarshallerAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 94101956d..f30ddb15e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -201,8 +201,7 @@ public static void WriteInterfaceVftbl(IndentedTextWriter writer, ProjectionEmit return; } - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -245,8 +244,7 @@ public static void WriteInterfaceImpl(IndentedTextWriter writer, ProjectionEmitC return; } - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); writer.WriteLine(); writer.WriteLine($"public static unsafe class {nameStripped}Impl"); @@ -454,8 +452,7 @@ public static void WriteInterfaceMarshaller(IndentedTextWriter writer, Projectio return; } - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); WriteTypedefNameCallback typedefName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, false); WriteTypeParamsCallback typeParams = TypedefNameWriter.WriteTypeParams(type); @@ -487,8 +484,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{typedefNam /// private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); // exclusive to a class (and not opted into PublicExclusiveTo) or if it's marked // [ProjectionInternal]; public otherwise. bool useInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 75f7971d2..89a2aca07 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -36,8 +36,7 @@ public static void WriteInterfaceIdicImpl(IndentedTextWriter writer, ProjectionE return; } - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); WriteTypedefNameWithTypeParamsCallback parent = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); WriteGuidAttributeCallback guidAttr = InterfaceFactory.WriteGuidAttribute(type); diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index d29efb86b..7aa401081 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -25,8 +25,7 @@ internal static class ReferenceImplFactory /// The type definition. public static void WriteReferenceImpl(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); string visibility = context.Settings.Component ? "public" : "file"; bool blittable = AbiTypeHelpers.IsTypeBlittable(context.Cache, type); diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index a7cb97bd0..31e2a2136 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -21,8 +21,7 @@ internal static class StructEnumMarshallerFactory /// internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string name = type.Name?.Value ?? string.Empty; - string nameStripped = IdentifierEscaping.StripBackticks(name); + string nameStripped = type.GetStrippedName(); TypeCategory cat = TypeCategorization.GetCategory(type); // "Almost-blittable" includes blittable + bool/char fields. Excludes string/object fields. // Use the same predicate as IsAnyStruct (which is now scoped to almost-blittable). diff --git a/src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs new file mode 100644 index 000000000..45bfbaa53 --- /dev/null +++ b/src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; + +namespace WindowsRuntime.ProjectionWriter.Helpers; + +/// +/// Extension methods on and related metadata types. +/// +internal static class TypeDefOrRefExtensions +{ + /// + /// Returns the type's metadata name with any generic-arity backtick suffix stripped + /// (e.g. "IList`1" becomes "IList"). When the type has no name, returns + /// . + /// + /// The type to derive the stripped name from. + /// The type's stripped name. + public static string GetStrippedName(this ITypeDefOrRef type) + { + return IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); + } +} From da1994241d2cdcc95a5af259fdb047218373a92c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:30:35 -0700 Subject: [PATCH 053/171] R6-3: WriteCallArgumentsCallback for argument-forwarding loops Adds a `WriteCallArguments` writer-style helper + corresponding `WriteCallArgumentsCallback` to `MethodFactory`. The helper takes a `bool leadingComma` flag to support both shapes: - `leadingComma: true` -> emits `, p1, p2, ..., pN` (for appending to a call site that already passed at least one arg, e.g. an objref). - `leadingComma: false` -> emits `p1, p2, ..., pN` (for the first argument of a call). Internally wraps the existing `WriteParameterNameWithModifierCallback` per element so all in/out/escape logic stays centralized. 6 hand-rolled per-element loops collapse to a single `{args}` interpolation hole inside a one-line `writer.WriteLine($`"...({args});")`: - ClassFactory.cs:368-374 (static method dispatch) - ClassMembersFactory.WriteInterfaceMembers.cs:339-345 (accessor dispatch) - ClassMembersFactory.WriteInterfaceMembers.cs:365-371 (instance dispatch) - ClassMembersFactory.WriteInterfaceMembers.cs:385-391 (overridable interface impl) - AbiInterfaceIDicFactory.cs:307-313 (IDIC method forwarder) - AbiInterfaceIDicFactory.cs:446-451 (IDIC method dispatch) Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceIDicFactory.cs | 17 +++-------- .../Callbacks/WriteCallArgumentsCallback.cs | 23 +++++++++++++++ .../Factories/ClassFactory.cs | 9 ++---- ...assMembersFactory.WriteInterfaceMembers.cs | 27 ++++-------------- .../Factories/MethodFactory.cs | 28 +++++++++++++++++++ 5 files changed, 63 insertions(+), 41 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteCallArgumentsCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 89a2aca07..914e42086 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -287,13 +287,8 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented writer.WriteLine(); WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); - writer.Write($"{ret} {ccwIfaceName}.{mname}({parms}) => (({ccwIfaceName})(WindowsRuntimeObject)this).{mname}("); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); - writer.Write($"{(i > 0 ? ", " : "")}{p}"); - } - writer.WriteLine(");"); + WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: false); + writer.WriteLine($"{ret} {ccwIfaceName}.{mname}({parms}) => (({ccwIfaceName})(WindowsRuntimeObject)this).{mname}({args});"); } foreach (PropertyDefinition prop in type.Properties) @@ -426,12 +421,8 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite """); writer.WriteIf(sig.ReturnType is not null, "return "); - writer.Write($"{abiClass}.{mname}(_obj"); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); - writer.Write($", {p}"); - } + WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: true); + writer.Write($"{abiClass}.{mname}(_obj{args}"); writer.WriteLine(isMultiline: true, """ ); } diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteCallArgumentsCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteCallArgumentsCallback.cs new file mode 100644 index 000000000..056ddcf2c --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteCallArgumentsCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteCallArgumentsCallback( + ProjectionEmitContext context, + MethodSignatureInfo sig, + bool leadingComma) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MethodFactory.WriteCallArguments(writer, context, sig, leadingComma); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index d2a9b7e9b..b0e9f3067 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -365,13 +365,8 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection } else { - writer.Write($") => {abiClass}.{mname}({objRef}"); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); - writer.Write($", {p}"); - } - writer.WriteLine(");"); + WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: true); + writer.WriteLine($") => {abiClass}.{mname}({objRef}{args});"); } } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 24f6b9025..aa49c50d3 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -336,13 +336,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE } else { - writer.Write($") => {accessorName}(null, {objRef}"); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteParameterNameWithModifierCallback p = WriteParameterNameWithModifier(context, sig.Parameters[i]); - writer.Write($", {p}"); - } - writer.WriteLine(");"); + WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: true); + writer.WriteLine($") => {accessorName}(null, {objRef}{args});"); } } else @@ -362,13 +357,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE } else { - writer.Write($") => {abiClass}.{name}({objRef}"); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteParameterNameWithModifierCallback p = WriteParameterNameWithModifier(context, sig.Parameters[i]); - writer.Write($", {p}"); - } - writer.WriteLine(");"); + WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: true); + writer.WriteLine($") => {abiClass}.{name}({objRef}{args});"); } } @@ -382,13 +372,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); WriteInterfaceTypeNameForCcwCallback iface = WriteInterfaceTypeNameForCcw(context, originalInterface); - writer.Write($"{ret} {iface}.{name}({parms}) => {name}("); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteParameterNameWithModifierCallback p = WriteParameterNameWithModifier(context, sig.Parameters[i]); - writer.Write($"{(i > 0 ? ", " : "")}{p}"); - } - writer.WriteLine(");"); + WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: false); + writer.WriteLine($"{ret} {iface}.{name}({parms}) => {name}({args});"); } } diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index f8ff6306e..f5e6c9bd5 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -189,6 +189,34 @@ public static WriteParameterListCallback WriteParameterList(ProjectionEmitContex return new(context, sig); } + /// + /// Writes a comma-separated argument-forwarding list (parameter names with in/out modifiers). + /// When is , the list is preceded by + /// ", " (so it can be appended to a call site that already passed one or more args); + /// otherwise, the comma separator appears only between elements. + /// + /// The writer to emit to. + /// The active emit context. + /// The method signature whose parameters to forward. + /// When , emits a leading ", " before the first element. + public static void WriteCallArguments(IndentedTextWriter writer, ProjectionEmitContext context, MethodSignatureInfo sig, bool leadingComma) + { + for (int i = 0; i < sig.Parameters.Count; i++) + { + WriteParameterNameWithModifierCallback p = ClassMembersFactory.WriteParameterNameWithModifier(context, sig.Parameters[i]); + string sep = (leadingComma || i > 0) ? ", " : ""; + + writer.Write($"{sep}{p}"); + } + } + + /// + /// A callback that writes the call-argument list to the writer it's appended to. + public static WriteCallArgumentsCallback WriteCallArguments(ProjectionEmitContext context, MethodSignatureInfo sig, bool leadingComma) + { + return new(context, sig, leadingComma); + } + /// /// Returns the C# literal text for a constant field's value (or empty when no constant). /// From bb194286ccac66586867e7d535d943e9ef642ba4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:32:54 -0700 Subject: [PATCH 054/171] R6-21: WriteProjectionParameter[Type]Callback for single-parameter sites Adds `WriteProjectionParameterCallback` (type + name) and `WriteProjectionParameterTypeCallback` (type only) + the matching factory overloads on `MethodFactory`. Migrates the 4 chunked single-parameter callsites: - ClassMembersFactory.WriteInterfaceMembers.cs:319 (UnsafeAccessor signature param) - ConstructorFactory.Composable.cs:89 (composable ctor user-param list) - ConstructorFactory.FactoryCallbacks.cs:39 (factory-args struct ctor list) - ConstructorFactory.FactoryCallbacks.cs:53 (factory-args struct field decl - uses TypeCallback) Each loop body becomes a single `writer.Write($`"{sep}{p}")` expression using the new callback. Together with the existing `WriteParameterNameWithModifierCallback` (per-element name + modifier) this unlocks single-multiline emission for several adjacent sites (R6-22 builds on this). Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../WriteProjectionParameterCallback.cs | 22 +++++++++++++++++++ .../WriteProjectionParameterTypeCallback.cs | 22 +++++++++++++++++++ ...assMembersFactory.WriteInterfaceMembers.cs | 4 ++-- .../ConstructorFactory.Composable.cs | 6 ++--- .../ConstructorFactory.FactoryCallbacks.cs | 15 +++++-------- .../Factories/MethodFactory.cs | 14 ++++++++++++ 6 files changed, 68 insertions(+), 15 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterTypeCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterCallback.cs new file mode 100644 index 000000000..0db1f9aba --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteProjectionParameterCallback( + ProjectionEmitContext context, + ParameterInfo parameter) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MethodFactory.WriteProjectionParameter(writer, context, parameter); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterTypeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterTypeCallback.cs new file mode 100644 index 000000000..eb17fe33c --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteProjectionParameterTypeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteProjectionParameterTypeCallback( + ProjectionEmitContext context, + ParameterInfo parameter) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MethodFactory.WriteProjectionParameterType(writer, context, parameter); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index aa49c50d3..4dfdfbcc4 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -315,8 +315,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE """); for (int i = 0; i < sig.Parameters.Count; i++) { - writer.Write(", "); - MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); + WriteProjectionParameterCallback p = MethodFactory.WriteProjectionParameter(context, sig.Parameters[i]); + writer.Write($", {p}"); } writer.WriteLine(");"); // string to each public method emission. In ref mode this produces e.g. diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index f807de4bb..5e2eba91d 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -3,6 +3,7 @@ using System.Globalization; using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Models; @@ -84,9 +85,8 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec writer.Write($"{typeName}("); for (int i = 0; i < userParamCount; i++) { - writer.WriteIf(i > 0, ", "); - - MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); + WriteProjectionParameterCallback p = MethodFactory.WriteProjectionParameter(context, sig.Parameters[i]); + writer.Write($"{(i > 0 ? ", " : "")}{p}"); } writer.Write(isMultiline: true, """ diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 5ad5fa7e9..a8bd444dc 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -34,9 +34,8 @@ private static void EmitFactoryArgsStruct(IndentedTextWriter writer, ProjectionE writer.Write($"private readonly ref struct {argsName}("); for (int i = 0; i < count; i++) { - writer.WriteIf(i > 0, ", "); - - MethodFactory.WriteProjectionParameter(writer, context, sig.Parameters[i]); + WriteProjectionParameterCallback p = MethodFactory.WriteProjectionParameter(context, sig.Parameters[i]); + writer.Write($"{(i > 0 ? ", " : "")}{p}"); } writer.WriteLine(isMultiline: true, """ ) @@ -45,13 +44,9 @@ private static void EmitFactoryArgsStruct(IndentedTextWriter writer, ProjectionE for (int i = 0; i < count; i++) { ParameterInfo p = sig.Parameters[i]; - string raw = p.Parameter.Name ?? "param"; - string pname = IdentifierEscaping.EscapeIdentifier(raw); - writer.Write(" public readonly "); - // Use the parameter's projected type (matches the constructor parameter type, including - // ReadOnlySpan/Span for array params). - MethodFactory.WriteProjectionParameterType(writer, context, p); - writer.WriteLine($" {pname} = {pname};"); + string pname = p.GetEscapedName(); + WriteProjectionParameterTypeCallback paramType = MethodFactory.WriteProjectionParameterType(context, p); + writer.WriteLine($" public readonly {paramType} {pname} = {pname};"); } writer.WriteLine("}"); } diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index f5e6c9bd5..a33436310 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -113,6 +113,13 @@ public static void WriteProjectionParameterType(IndentedTextWriter writer, Proje } } + /// + /// A callback that writes the projected parameter type to the writer it's appended to. + public static WriteProjectionParameterTypeCallback WriteProjectionParameterType(ProjectionEmitContext context, ParameterInfo p) + { + return new(context, p); + } + /// /// Writes the parameter name (escaped if it would clash with a C# keyword). /// @@ -140,6 +147,13 @@ public static void WriteProjectionParameter(IndentedTextWriter writer, Projectio WriteParameterName(writer, p); } + /// + /// A callback that writes the parameter (type + name) to the writer it's appended to. + public static WriteProjectionParameterCallback WriteProjectionParameter(ProjectionEmitContext context, ParameterInfo p) + { + return new(context, p); + } + /// /// Writes the projected return type of (or "void"). /// From a7c10118011a31c2256a4fd164d6640568f78ebc Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:35:42 -0700 Subject: [PATCH 055/171] R6-22: Consolidate generic interface method emission into one multiline The UnsafeAccessor + dispatch block in `ClassMembersFactory.WriteInterfaceMembers.cs:306-341` was 4 chunked emissions interleaved with a per-parameter loop and conditional ref/ non-ref dispatch. Collapse into a single multiline raw-string emission by pre-computing the variant locals first: - `accessorParams`: leading-comma-prefixed projected parameter list (built via the new `WriteProjectionParameter` callback's `.Format()` + `string.Concat` over the parameters). - `body`: `throw null;` in ref-projection mode, otherwise the `{accessor}(null, {objRef}{callArgs});` dispatch using the existing `WriteCallArguments` callback. - `platformTrimmed`: `platformAttribute` with its trailing newline stripped so the multiline template line that holds it doesn't produce a stray blank line when the attribute is empty (the writer's `AppendInterpolatedStringHandler` already suppresses the line when the hole expands to empty). The result: one `writer.WriteLine(isMultiline: true, $`"""...""")` whose shape directly mirrors the emitted source. Depends on R6-3 (`WriteCallArgumentsCallback`) and R6-21 (`WriteProjectionParameterCallback`). Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- ...assMembersFactory.WriteInterfaceMembers.cs | 43 ++++++------------- 1 file changed, 14 insertions(+), 29 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 4dfdfbcc4..9ca0e98fb 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Globalization; +using System.Linq; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; @@ -307,38 +308,22 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE { // Emit UnsafeAccessor static extern + body that dispatches through it. string accessorName = genericParentEncoded + "_" + name; - writer.WriteLine(); WriteProjectionReturnTypeCallback unsafeRet = MethodFactory.WriteProjectionReturnType(context, sig); - writer.Write(isMultiline: true, $$""" + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); + string accessorParams = string.Concat(sig.Parameters.Select(p => $", {MethodFactory.WriteProjectionParameter(context, p).Format()}")); + string body = context.Settings.ReferenceProjection + ? "throw null;" + : $"{accessorName}(null, {objRef}{MethodFactory.WriteCallArguments(context, sig, leadingComma: true).Format()});"; + string platformTrimmed = platformAttribute.TrimEnd('\r', '\n'); + + writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{name}}")] - static extern {{unsafeRet}} {{accessorName}}([UnsafeAccessorType("{{genericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference + static extern {{unsafeRet}} {{accessorName}}([UnsafeAccessorType("{{genericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference{{accessorParams}}); + {{platformTrimmed}} + {{access}}{{methodSpecForThis}}{{ret}} {{name}}({{parms}}) => {{body}} """); - for (int i = 0; i < sig.Parameters.Count; i++) - { - WriteProjectionParameterCallback p = MethodFactory.WriteProjectionParameter(context, sig.Parameters[i]); - writer.Write($", {p}"); - } - writer.WriteLine(");"); - // string to each public method emission. In ref mode this produces e.g. - // [global::System.Runtime.Versioning.SupportedOSPlatform("Windows10.0.16299.0")]. - writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); - - { - WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); - WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); - writer.Write($"{access}{methodSpecForThis}{ret} {name}({parms}"); - } - - if (context.Settings.ReferenceProjection) - { - // which emits 'throw null' in reference projection mode. - writer.WriteLine(") => throw null;"); - } - else - { - WriteCallArgumentsCallback args = MethodFactory.WriteCallArguments(context, sig, leadingComma: true); - writer.WriteLine($") => {accessorName}(null, {objRef}{args});"); - } } else { From 35016f03676554dc04d382b70bd45aa33d810877 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:36:44 -0700 Subject: [PATCH 056/171] R6-1: Deduplicate WriteDefault/ExclusiveToInterfacesClass The two methods at MetadataAttributeFactory.cs:402-460 were character-for-character identical except for 3 string literals: - the attribute name (`WindowsRuntimeDefaultInterface` vs `WindowsRuntimeExclusiveToInterface`) - the generated class name - the output file name Factor the shared 28-line body into a private `WriteInterfaceMapClass(settings, sortedEntries, attributeName, className, fileName)` method. The two public entry-point methods become 1-line wrappers. Removes ~30 lines of mechanical duplication and prevents drift between the two emitters. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/MetadataAttributeFactory.cs | 48 ++++++++----------- 1 file changed, 20 insertions(+), 28 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 4647c7061..9b2b25153 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -401,37 +401,29 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, /// public static void WriteDefaultInterfacesClass(Settings settings, IReadOnlyList> sortedEntries) { - if (sortedEntries.Count == 0) - { - return; - } - - using IndentedTextWriterOwner wOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter w = wOwner.Writer; - WriteFileHeader(w); - w.WriteLine("using System;"); - w.WriteLine("using WindowsRuntime;"); - w.WriteLine(); - w.WriteLine("#pragma warning disable CSWINRT3001"); - w.WriteLine(); - w.WriteLine("namespace ABI"); - using (w.WriteBlock()) - { - foreach (KeyValuePair kv in sortedEntries) - { - w.WriteLine($"[WindowsRuntimeDefaultInterface(typeof({kv.Key}), typeof({kv.Value}))]"); - } - - w.WriteLine("internal static class WindowsRuntimeDefaultInterfaces;"); - } - - w.FlushToFile(Path.Combine(settings.OutputFolder, "WindowsRuntimeDefaultInterfaces.cs")); + WriteInterfaceMapClass(settings, sortedEntries, "WindowsRuntimeDefaultInterface", "WindowsRuntimeDefaultInterfaces", "WindowsRuntimeDefaultInterfaces.cs"); } /// /// Writes the generated WindowsRuntimeExclusiveToInterfaces.cs file. /// public static void WriteExclusiveToInterfacesClass(Settings settings, IReadOnlyList> sortedEntries) + { + WriteInterfaceMapClass(settings, sortedEntries, "WindowsRuntimeExclusiveToInterface", "WindowsRuntimeExclusiveToInterfaces", "WindowsRuntimeExclusiveToInterfaces.cs"); + } + + /// + /// Shared template for emitting an ABI namespace-level static class decorated with one + /// per entry from (mapping + /// projected type names to interface or proxy type names). Used by both + /// and . + /// + private static void WriteInterfaceMapClass( + Settings settings, + IReadOnlyList> sortedEntries, + string attributeName, + string className, + string fileName) { if (sortedEntries.Count == 0) { @@ -451,12 +443,12 @@ public static void WriteExclusiveToInterfacesClass(Settings settings, IReadOnlyL { foreach (KeyValuePair kv in sortedEntries) { - w.WriteLine($"[WindowsRuntimeExclusiveToInterface(typeof({kv.Key}), typeof({kv.Value}))]"); + w.WriteLine($"[{attributeName}(typeof({kv.Key}), typeof({kv.Value}))]"); } - w.WriteLine("internal static class WindowsRuntimeExclusiveToInterfaces;"); + w.WriteLine($"internal static class {className};"); } - w.FlushToFile(Path.Combine(settings.OutputFolder, "WindowsRuntimeExclusiveToInterfaces.cs")); + w.FlushToFile(Path.Combine(settings.OutputFolder, fileName)); } } From e07f322734279ba7481fa33dd221e529a73bd3b7 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:45:51 -0700 Subject: [PATCH 057/171] R6-2: Callbackify MetadataAttributeFactory Write*Attribute helpers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds 6 callback variants for the per-attribute helpers in `MetadataAttributeFactory` + 1 for `CustomAttributeFactory.WriteTypeCustomAttributes`, plus internal `*Body` helpers that emit the attribute body without the trailing newline. The writer-version of each helper is preserved and now delegates to its body method + `writer.WriteLine()` (conditional on the body having written anything, for the 3 ref-projection-gated helpers). The attribute-per-bracket invariant is preserved: each callback emits exactly one `[Attr(...)]` and nothing else. Multiple attributes are never merged into a comma-separated `[A, B]` list — the multiline template provides one line per attribute hole. Conditional emission flows through cleanly: the 3 ref-projection-gated helpers (`WriteValueTypeWinRTClassNameAttribute`, `WriteWinRTReferenceTypeAttribute`, `WriteComWrapperMarshallerAttribute`) emit nothing in ref-projection mode, and the blank-line suppression in `AppendInterpolatedStringHandler` (commit 158a9813) drops the empty template line so output stays byte-identical. Migrates 7 type-header emission sites to single multiline raw-string templates: - `InterfaceFactory.cs:427`: metadata + Guid (2 attrs + decl header) - `ProjectionFileBuilder.cs:107` (enum): 5 attrs + decl - `ProjectionFileBuilder.cs:218` (struct): 5 attrs + decl - `ProjectionFileBuilder.cs:381` (attribute class): 2 attrs + decl - `ClassFactory.cs:285` (static class): 2 attrs + decl - `ClassFactory.cs:570` (runtime class): 3 attrs + decl - `AbiStructFactory.cs:35` (struct marshaller): conditional component vs. com-wrappers attrs + value-type attr + decl The delegate site (`ProjectionFileBuilder.cs:WriteDelegate`) is deferred to R6-27 because it has additional inline `IidExpressionGenerator.WriteGuid` state that wants its own consolidation. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 54 +++++--- .../Factories/AbiStructFactory.cs | 25 ++-- ...teComWrapperMarshallerAttributeCallback.cs | 22 +++ .../WriteTypeCustomAttributesCallback.cs | 23 ++++ ...alueTypeWinRTClassNameAttributeCallback.cs | 22 +++ .../WriteWinRTMappedTypeAttributeCallback.cs | 22 +++ .../WriteWinRTMetadataAttributeCallback.cs | 22 +++ ...eWinRTMetadataTypeNameAttributeCallback.cs | 22 +++ ...riteWinRTReferenceTypeAttributeCallback.cs | 22 +++ .../Factories/ClassFactory.cs | 27 ++-- .../Factories/CustomAttributeFactory.cs | 29 +++- .../Factories/InterfaceFactory.cs | 7 +- .../Factories/MetadataAttributeFactory.cs | 130 ++++++++++++++++-- 13 files changed, 373 insertions(+), 54 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteComWrapperMarshallerAttributeCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeCustomAttributesCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteValueTypeWinRTClassNameAttributeCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMappedTypeAttributeCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataAttributeCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataTypeNameAttributeCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTReferenceTypeAttributeCallback.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index c8aae02e9..896464bd1 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -109,17 +109,22 @@ public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext co string accessibility = context.Settings.Internal ? "internal" : "public"; string typeName = type.Name?.Value ?? string.Empty; + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); + WriteValueTypeWinRTClassNameAttributeCallback valueTypeAttr = MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(context, type); + WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); + WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); + WriteWinRTReferenceTypeAttributeCallback refTypeAttr = MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(context, type); + writer.WriteLine(); writer.WriteLineIf(isFlags, "[Flags]"); - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(writer, context, type); - CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); - MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); - MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(writer, context, type); - writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{valueTypeAttr}} + {{customAttrs}} + {{comWrappersAttr}} + {{refTypeAttr}} {{accessibility}} enum {{typeName}} : {{enumUnderlyingType}} """); using (writer.WriteBlock()) @@ -215,17 +220,21 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext string projectionName = type.Name?.Value ?? string.Empty; bool hasAddition = AdditionTypes.HasAdditionToType(type.Namespace?.Value ?? string.Empty, projectionName); - // Header attributes - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(writer, context, type); - CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); - MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); - MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(writer, context, type); - writer.Write("public"); - - writer.WriteIf(hasAddition, " partial"); - - writer.WriteLine($" struct {projectionName} : IEquatable<{projectionName}>"); + // Header attributes + struct declaration as a single multiline template. + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); + WriteValueTypeWinRTClassNameAttributeCallback valueTypeAttr = MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(context, type); + WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); + WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); + WriteWinRTReferenceTypeAttributeCallback refTypeAttr = MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(context, type); + string partial = hasAddition ? " partial" : ""; + writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{valueTypeAttr}} + {{customAttrs}} + {{comWrappersAttr}} + {{refTypeAttr}} + public{{partial}} struct {{projectionName}} : IEquatable<{{projectionName}}> + """); using (writer.WriteBlock()) { writer.Write($"public {projectionName}("); @@ -380,10 +389,15 @@ public static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitConte { string typeName = type.Name?.Value ?? string.Empty; + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); + WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); + writer.WriteLine(); - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); - writer.WriteLine($"{context.Settings.InternalAccessibility} sealed class {typeName} : Attribute"); + writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{customAttrs}} + {{context.Settings.InternalAccessibility}} sealed class {{typeName}} : Attribute + """); using (writer.WriteBlock()) { // Constructors diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index 972f03e4f..1605b13db 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -3,6 +3,7 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; @@ -37,20 +38,16 @@ public static void WriteAbiStruct(IndentedTextWriter writer, ProjectionEmitConte // In component mode emit the [WindowsRuntimeMetadataTypeName]/[WindowsRuntimeMappedType] // attribute pair; otherwise emit the [ComWrappersMarshaller] attribute. Both branches // then emit [WindowsRuntimeClassName] + the struct definition with public ABI fields. - if (context.Settings.Component) - { - MetadataAttributeFactory.WriteWinRTMetadataTypeNameAttribute(writer, context, type); - MetadataAttributeFactory.WriteWinRTMappedTypeAttribute(writer, context, type); - } - else - { - MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); - } - - MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(writer, context, type); - writer.Write($"{context.Settings.InternalAccessibility} unsafe struct "); - writer.Write(IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty)); - writer.WriteLine(); + string nameStripped = type.GetStrippedName(); + string marshallerOrTypeAttrs = context.Settings.Component + ? $"{MetadataAttributeFactory.WriteWinRTMetadataTypeNameAttribute(context, type).Format()}\n{MetadataAttributeFactory.WriteWinRTMappedTypeAttribute(context, type).Format()}" + : MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type).Format(); + WriteValueTypeWinRTClassNameAttributeCallback valueTypeAttr = MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(context, type); + writer.WriteLine(isMultiline: true, $$""" + {{marshallerOrTypeAttrs}} + {{valueTypeAttr}} + {{context.Settings.InternalAccessibility}} unsafe struct {{nameStripped}} + """); using (writer.WriteBlock()) { foreach (FieldDefinition field in type.Fields) diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteComWrapperMarshallerAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteComWrapperMarshallerAttributeCallback.cs new file mode 100644 index 000000000..7ff65f297 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteComWrapperMarshallerAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteComWrapperMarshallerAttributeCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MetadataAttributeFactory.WriteComWrapperMarshallerAttributeBody(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeCustomAttributesCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeCustomAttributesCallback.cs new file mode 100644 index 000000000..9e3db06d6 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteTypeCustomAttributesCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteTypeCustomAttributesCallback( + ProjectionEmitContext context, + TypeDefinition type, + bool enablePlatformAttrib) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + CustomAttributeFactory.WriteTypeCustomAttributesBody(writer, context, type, enablePlatformAttrib); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteValueTypeWinRTClassNameAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteValueTypeWinRTClassNameAttributeCallback.cs new file mode 100644 index 000000000..3eb4f4bd2 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteValueTypeWinRTClassNameAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteValueTypeWinRTClassNameAttributeCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttributeBody(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMappedTypeAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMappedTypeAttributeCallback.cs new file mode 100644 index 000000000..1ac346cdc --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMappedTypeAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteWinRTMappedTypeAttributeCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MetadataAttributeFactory.WriteWinRTMappedTypeAttributeBody(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataAttributeCallback.cs new file mode 100644 index 000000000..8f645a047 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteWinRTMetadataAttributeCallback( + TypeDefinition type, + MetadataCache cache) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MetadataAttributeFactory.WriteWinRTMetadataAttributeBody(writer, type, cache); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataTypeNameAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataTypeNameAttributeCallback.cs new file mode 100644 index 000000000..38f870b25 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTMetadataTypeNameAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteWinRTMetadataTypeNameAttributeCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MetadataAttributeFactory.WriteWinRTMetadataTypeNameAttributeBody(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTReferenceTypeAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTReferenceTypeAttributeCallback.cs new file mode 100644 index 000000000..8c920cd22 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteWinRTReferenceTypeAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WriteWinRTReferenceTypeAttributeCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + MetadataAttributeFactory.WriteWinRTReferenceTypeAttributeBody(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index b0e9f3067..71ad7c211 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -286,10 +286,14 @@ public static void WriteStaticClass(IndentedTextWriter writer, ProjectionEmitCon { using (context.EnterPlatformSuppressionScope(string.Empty)) { - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); + WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); - writer.WriteLine($"{context.Settings.InternalAccessibility} static class {name}"); + writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{customAttrs}} + {{context.Settings.InternalAccessibility}} static class {{name}} + """); using (writer.WriteBlock()) { WriteStaticClassMembers(writer, context, type); @@ -570,17 +574,22 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont string typeName = type.Name?.Value ?? string.Empty; int gcPressure = GetGcPressureAmount(type); - // Header attributes - writer.WriteLine(); - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, true); - MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); + // Header attributes + class declaration as a single multiline template. + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); + WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); + WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); string accessibility = context.Settings.Internal ? "internal" : "public"; // are emitted as plain (non-partial) classes. string modifiers = TypeCategorization.IsStatic(type) ? "static " : type.IsSealed ? "sealed " : ""; WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); WriteTypeInheritanceCallback inheritance = InterfaceFactory.WriteTypeInheritance(context, type, false, true); - writer.WriteLine($"{accessibility} {modifiers}class {name}{inheritance}"); + writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{customAttrs}} + {{comWrappersAttr}} + {{accessibility}} {{modifiers}}class {{name}}{{inheritance}} + """); using IndentedTextWriter.Block __classBlock = writer.WriteBlock(); // ObjRef field definitions for each implemented interface. diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index 865a13782..e958ffbf2 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -8,6 +8,7 @@ using AsmResolver; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Writers; @@ -436,7 +437,8 @@ public static void WriteCustomAttributes(IndentedTextWriter writer, ProjectionEm } /// - /// Writes the type-level custom attributes for . + /// Writes the projected type-level custom attributes for . Each emitted + /// attribute is on its own line, terminated with a newline. If no attributes apply, emits nothing. /// /// The writer to emit to. /// The active emit context. @@ -447,4 +449,29 @@ public static void WriteTypeCustomAttributes(IndentedTextWriter writer, Projecti WriteCustomAttributes(writer, context, type, enablePlatformAttrib); } + /// + /// A callback emitting each applicable attribute on its own line. The trailing newline of the last attribute is dropped so the callback can be interpolated into a multiline template line without producing a stray blank line. + public static WriteTypeCustomAttributesCallback WriteTypeCustomAttributes(ProjectionEmitContext context, TypeDefinition type, bool enablePlatformAttrib) + { + return new(context, type, enablePlatformAttrib); + } + + /// + /// Writes just the attribute lines (no trailing newline on the last one) for + /// . + /// Used by the callback variant so the callback can be inlined inside a multiline raw-string + /// template — the surrounding template line's own newline becomes the trailing newline. + /// + internal static void WriteTypeCustomAttributesBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, bool enablePlatformAttrib) + { + int before = writer.Length; + WriteCustomAttributes(writer, context, type, enablePlatformAttrib); + // If anything was written, the buffer ends with a trailing newline that came from the + // last attribute's WriteLine. Trim it so the callback can be inlined into a multiline + // template line without producing a stray blank line. + if (writer.Length > before && writer.Length > 0 && writer.Back() == '\n') + { + writer.Remove(writer.Length - 1, 1); + } + } } diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 2acf87fcc..7a2fd8817 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -425,9 +425,12 @@ public static void WriteInterface(IndentedTextWriter writer, ProjectionEmitConte } writer.WriteLine(); - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); WriteGuidAttributeCallback guidAttr = WriteGuidAttribute(type); - writer.WriteLine($"{guidAttr}"); + writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{guidAttr}} + """); CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); bool isInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) || diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 9b2b25153..410b5ddf7 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -78,16 +78,33 @@ public static string GetFileHeader() } /// - /// Writes a [WindowsRuntimeMetadata] attribute decorating with its source .winmd module name. + /// Writes a [WindowsRuntimeMetadata("<stem>")] attribute decorating with its source .winmd module name. /// /// The writer to emit to. /// The type definition. /// The metadata cache used to resolve the source module path. public static void WriteWinRTMetadataAttribute(IndentedTextWriter writer, TypeDefinition type, MetadataCache cache) + { + WriteWinRTMetadataAttributeBody(writer, type, cache); + writer.WriteLine(); + } + + /// + /// A callback emitting the attribute body (no trailing newline) so it can be interpolated into a multiline template. + public static WriteWinRTMetadataAttributeCallback WriteWinRTMetadataAttribute(TypeDefinition type, MetadataCache cache) + { + return new(type, cache); + } + + /// + /// Writes just the attribute body (no trailing newline) for . + /// Used by the callback variant to allow the attribute to be inlined inside a multiline raw-string template line. + /// + internal static void WriteWinRTMetadataAttributeBody(IndentedTextWriter writer, TypeDefinition type, MetadataCache cache) { string path = cache.GetSourcePath(type); string stem = string.IsNullOrEmpty(path) ? string.Empty : Path.GetFileNameWithoutExtension(path); - writer.WriteLine($"[WindowsRuntimeMetadata(\"{stem}\")]"); + writer.Write($"[WindowsRuntimeMetadata(\"{stem}\")]"); } /// @@ -97,10 +114,26 @@ public static void WriteWinRTMetadataAttribute(IndentedTextWriter writer, TypeDe /// The active emit context. /// The type definition. public static void WriteWinRTMetadataTypeNameAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + { + WriteWinRTMetadataTypeNameAttributeBody(writer, context, type); + writer.WriteLine(); + } + + /// + /// A callback emitting the attribute body (no trailing newline) so it can be interpolated into a multiline template. + public static WriteWinRTMetadataTypeNameAttributeCallback WriteWinRTMetadataTypeNameAttribute(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + + /// + /// Writes just the attribute body (no trailing newline) for . + /// + internal static void WriteWinRTMetadataTypeNameAttributeBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { WriteTypedefNameWithTypeParamsCallback typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); - writer.WriteLine($"""[WindowsRuntimeMetadataTypeName("{typeName}")]"""); + writer.Write($"""[WindowsRuntimeMetadataTypeName("{typeName}")]"""); } /// @@ -110,19 +143,57 @@ public static void WriteWinRTMetadataTypeNameAttribute(IndentedTextWriter writer /// The active emit context. /// The type definition. public static void WriteWinRTMappedTypeAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + { + WriteWinRTMappedTypeAttributeBody(writer, context, type); + writer.WriteLine(); + } + + /// + /// A callback emitting the attribute body (no trailing newline) so it can be interpolated into a multiline template. + public static WriteWinRTMappedTypeAttributeCallback WriteWinRTMappedTypeAttribute(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + + /// + /// Writes just the attribute body (no trailing newline) for . + /// + internal static void WriteWinRTMappedTypeAttributeBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { WriteTypedefNameWithTypeParamsCallback typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); - writer.WriteLine($"[WindowsRuntimeMappedType(typeof({typeName}))]"); + writer.Write($"[WindowsRuntimeMappedType(typeof({typeName}))]"); } /// /// Writes a [WindowsRuntimeClassName("Windows.Foundation.IReference`1<NS.Name>")] attribute for a value type. + /// Skipped entirely in reference-projection mode. /// /// The writer to emit to. /// The active emit context. /// The value type definition. public static void WriteValueTypeWinRTClassNameAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + { + int before = writer.Length; + WriteValueTypeWinRTClassNameAttributeBody(writer, context, type); + if (writer.Length > before) + { + writer.WriteLine(); + } + } + + /// + /// A callback emitting the attribute body (no trailing newline) so it can be interpolated into a multiline template. Emits nothing in reference-projection mode (which combined with the writer's blank-line suppression collapses the would-be template line). + public static WriteValueTypeWinRTClassNameAttributeCallback WriteValueTypeWinRTClassNameAttribute(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + + /// + /// Writes just the attribute body (no trailing newline) for . + /// In reference-projection mode this emits nothing. + /// + internal static void WriteValueTypeWinRTClassNameAttributeBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.ReferenceProjection) { @@ -130,16 +201,38 @@ public static void WriteValueTypeWinRTClassNameAttribute(IndentedTextWriter writ } (string ns, string name) = type.Names(); - writer.WriteLine($"[WindowsRuntimeClassName(\"Windows.Foundation.IReference`1<{ns}.{name}>\")]"); + writer.Write($"[WindowsRuntimeClassName(\"Windows.Foundation.IReference`1<{ns}.{name}>\")]"); } /// /// Writes a [WindowsRuntimeReferenceType(typeof(NullableX))] attribute on a reference type. + /// Skipped entirely in reference-projection mode. /// /// The writer to emit to. /// The active emit context. /// The reference type definition. public static void WriteWinRTReferenceTypeAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + { + int before = writer.Length; + WriteWinRTReferenceTypeAttributeBody(writer, context, type); + if (writer.Length > before) + { + writer.WriteLine(); + } + } + + /// + /// A callback emitting the attribute body (no trailing newline) so it can be interpolated into a multiline template. Emits nothing in reference-projection mode. + public static WriteWinRTReferenceTypeAttributeCallback WriteWinRTReferenceTypeAttribute(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + + /// + /// Writes just the attribute body (no trailing newline) for . + /// In reference-projection mode this emits nothing. + /// + internal static void WriteWinRTReferenceTypeAttributeBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.ReferenceProjection) { @@ -148,16 +241,37 @@ public static void WriteWinRTReferenceTypeAttribute(IndentedTextWriter writer, P WriteTypedefNameWithTypeParamsCallback typeName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); - writer.WriteLine($"[WindowsRuntimeReferenceType(typeof({typeName}?))]"); + writer.Write($"[WindowsRuntimeReferenceType(typeof({typeName}?))]"); } /// - /// Writes the [ABI.NS.NameComWrappersMarshaller] attribute. + /// Writes the [ABI.NS.NameComWrappersMarshaller] attribute. Skipped entirely in reference-projection mode. /// /// The writer to emit to. /// The active emit context. /// The type definition. public static void WriteComWrapperMarshallerAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + { + int before = writer.Length; + WriteComWrapperMarshallerAttributeBody(writer, context, type); + if (writer.Length > before) + { + writer.WriteLine(); + } + } + + /// + /// A callback emitting the attribute body (no trailing newline) so it can be interpolated into a multiline template. Emits nothing in reference-projection mode. + public static WriteComWrapperMarshallerAttributeCallback WriteComWrapperMarshallerAttribute(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + + /// + /// Writes just the attribute body (no trailing newline) for . + /// In reference-projection mode this emits nothing. + /// + internal static void WriteComWrapperMarshallerAttributeBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.ReferenceProjection) { @@ -165,7 +279,7 @@ public static void WriteComWrapperMarshallerAttribute(IndentedTextWriter writer, } (string ns, string name) = type.Names(); - writer.WriteLine($"[ABI.{ns}.{IdentifierEscaping.StripBackticks(name)}ComWrappersMarshaller]"); + writer.Write($"[ABI.{ns}.{IdentifierEscaping.StripBackticks(name)}ComWrappersMarshaller]"); } /// From 874e7788e8e6bc52e65b2b0cde43c019244bfda9 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:48:15 -0700 Subject: [PATCH 058/171] R6-15: WritePlatformAttribute callback + GetPlatformAttribute rename MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Splits `CustomAttributeFactory.WritePlatformAttribute` into a body helper (no trailing newline) + a writer-version that conditionally adds the newline (matching the existing pattern from R6-2). Adds a `WritePlatformAttributeCallback` so the attribute can be inlined inside a multiline raw-string template. Renames the existing string-returning overload to `GetPlatformAttribute` (preserves backwards-compatible semantics: returns the attribute INCLUDING its trailing newline so existing `WriteIf(!string.IsNullOrEmpty(p), p)` callers keep working). The rename was necessary because the new callback factory has the same `(context, member)` parameter shape that the old string overload had — they would otherwise collide. Updates the 4 callsites (ClassFactory.cs:345, ConstructorFactory.{AttributedTypes,Composable}.cs, ClassMembersFactory.WriteInterfaceMembers.cs:251) to call `GetPlatformAttribute` instead. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../WritePlatformAttributeCallback.cs | 22 ++++++++++++++ .../Factories/ClassFactory.cs | 2 +- ...assMembersFactory.WriteInterfaceMembers.cs | 2 +- .../ConstructorFactory.AttributedTypes.cs | 2 +- .../ConstructorFactory.Composable.cs | 2 +- .../Factories/CustomAttributeFactory.cs | 30 +++++++++++++++++-- 6 files changed, 53 insertions(+), 7 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WritePlatformAttributeCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WritePlatformAttributeCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WritePlatformAttributeCallback.cs new file mode 100644 index 000000000..390feb82b --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WritePlatformAttributeCallback.cs @@ -0,0 +1,22 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct WritePlatformAttributeCallback( + ProjectionEmitContext context, + IHasCustomAttribute member) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + CustomAttributeFactory.WritePlatformAttributeBody(writer, context, member); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 71ad7c211..4c430a4ee 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -342,7 +342,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection // Compute the platform attribute string from the static factory interface's // [ContractVersion] attribute - string platformAttribute = CustomAttributeFactory.WritePlatformAttribute(context, staticIface); + string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, staticIface); // Methods foreach (MethodDefinition method in staticIface.Methods) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 9ca0e98fb..0fe70f55b 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -248,7 +248,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // class members carry [SupportedOSPlatform("WindowsX.Y.Z.0")] mirroring the interface's // contract version. Only emitted in ref mode (WritePlatformAttribute internally returns // immediately if not ref) - string platformAttribute = CustomAttributeFactory.WritePlatformAttribute(context, ifaceType); + string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, ifaceType); // Methods foreach (MethodDefinition method in ifaceType.Methods) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 44e93e128..2802226d9 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -104,7 +104,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio string marshalingType = GetMarshalingTypeName(classType); // Compute the platform attribute string from the activation factory interface's // [ContractVersion] attribute - string platformAttribute = CustomAttributeFactory.WritePlatformAttribute(context, factoryType); + string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, factoryType); int methodIndex = 0; foreach (MethodDefinition method in factoryType.Methods) { diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 5e2eba91d..534c1b84f 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -44,7 +44,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec int gcPressure = ClassFactory.GetGcPressureAmount(classType); // Compute the platform attribute string from the composable factory interface's // [ContractVersion] attribute - string platformAttribute = CustomAttributeFactory.WritePlatformAttribute(context, composableType); + string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, composableType); int methodIndex = 0; foreach (MethodDefinition method in composableType.Methods) diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index e958ffbf2..0c753b1e3 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -277,6 +277,28 @@ private static string GetPlatform(ProjectionEmitContext context, CustomAttribute /// The active emit context. /// The member to inspect for [ContractVersion]. public static void WritePlatformAttribute(IndentedTextWriter writer, ProjectionEmitContext context, IHasCustomAttribute member) + { + int before = writer.Length; + WritePlatformAttributeBody(writer, context, member); + if (writer.Length > before) + { + writer.WriteLine(); + } + } + + /// + /// A callback emitting the attribute body (no trailing newline). Emits nothing when no [SupportedOSPlatform] applies (or when not in reference-projection mode). The blank-line suppression in the writer collapses any template line that holds only this callback when it expands to empty. + public static WritePlatformAttributeCallback WritePlatformAttribute(ProjectionEmitContext context, IHasCustomAttribute member) + { + return new(context, member); + } + + /// + /// Writes just the attribute body (no trailing newline) for + /// . + /// In non-reference-projection mode this emits nothing. + /// + internal static void WritePlatformAttributeBody(IndentedTextWriter writer, ProjectionEmitContext context, IHasCustomAttribute member) { if (!context.Settings.ReferenceProjection) { @@ -306,7 +328,7 @@ public static void WritePlatformAttribute(IndentedTextWriter writer, ProjectionE if (!string.IsNullOrEmpty(platform)) { - writer.WriteLine($"[global::System.Runtime.Versioning.SupportedOSPlatform({platform})]"); + writer.Write($"[global::System.Runtime.Versioning.SupportedOSPlatform({platform})]"); return; } } @@ -317,12 +339,14 @@ public static void WritePlatformAttribute(IndentedTextWriter writer, ProjectionE /// Convenience overload of /// that leases an from , /// emits the [SupportedOSPlatform] attribute (if any) into it, and returns the - /// resulting string. Returns the empty string when no attribute is emitted. + /// resulting string (including the trailing newline). Returns the empty string when no + /// attribute is emitted. Used by callers that materialize the result once and use it + /// inside multiple calls within a loop. /// /// The active emit context. /// The member to inspect for [ContractVersion]. /// The emitted attribute, or when none. - public static string WritePlatformAttribute(ProjectionEmitContext context, IHasCustomAttribute member) + public static string GetPlatformAttribute(ProjectionEmitContext context, IHasCustomAttribute member) { using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); IndentedTextWriter writer = writerOwner.Writer; From a9a2e3e41ae3b1ed61e0671a8ca176e63c6fc837 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:50:11 -0700 Subject: [PATCH 059/171] =?UTF-8?q?R6-8:=20EmitMarshallerConvertToUn/Manag?= =?UTF-8?q?ed=20=E2=86=92=20callback=20pair?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds `EmitMarshallerConvertToUnmanagedCallback` + `EmitMarshallerConvertToManagedCallback` + factory overloads on `AbiMethodBodyFactory`. Migrates the 3 chunked callsites where the helper was sandwiched between `writer.Write(prefix)` and `writer.WriteLine(suffix)` calls: - `AbiMethodBodyFactory.DoAbi.cs:665-667` (DetachThisPtrUnsafe assignment) - `AbiMethodBodyFactory.RcwCaller.cs:267-269` (using-ref-value declaration) - `AbiMethodBodyFactory.RcwCaller.cs:1245-1247` (return statement) - `ConstructorFactory.FactoryCallbacks.cs:196-198` (factory using-ref-value declaration) Each becomes one `writer.WriteLine($`"...{cvt}...;")`. The 5th site at `AbiMethodBodyFactory.DoAbi.cs:809` (inside `EmitDoAbiParamArgConversion`) is left as a writer-style call — it's the conversion emission for one branch of a larger switch, not a prefix/suffix sandwich pattern, so the writer-style call is the clear shape there. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 5 ++-- ...AbiMethodBodyFactory.MarshallerDispatch.cs | 15 ++++++++++++ .../AbiMethodBodyFactory.RcwCaller.cs | 10 ++++---- .../EmitMarshallerConvertToManagedCallback.cs | 23 +++++++++++++++++++ ...mitMarshallerConvertToUnmanagedCallback.cs | 23 +++++++++++++++++++ .../ConstructorFactory.FactoryCallbacks.cs | 5 ++-- 6 files changed, 69 insertions(+), 12 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToManagedCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToUnmanagedCallback.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index a0f8ced40..29dae4655 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -662,9 +662,8 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else { - writer.Write($" *{retParamName} = "); - EmitMarshallerConvertToUnmanaged(writer, context, rt!, retLocalName); - writer.WriteLine(".DetachThisPtrUnsafe();"); + EmitMarshallerConvertToUnmanagedCallback cvt = EmitMarshallerConvertToUnmanaged(context, rt!, retLocalName); + writer.WriteLine($" *{retParamName} = {cvt}.DetachThisPtrUnsafe();"); } } else if (returnIsReceiveArrayDoAbi) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MarshallerDispatch.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MarshallerDispatch.cs index dbf54502a..55eef1243 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MarshallerDispatch.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MarshallerDispatch.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Writers; @@ -25,6 +26,13 @@ internal static void EmitMarshallerConvertToUnmanaged(IndentedTextWriter writer, writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, sig)}.ConvertToUnmanaged({argName})"); } + /// + /// A callback emitting the marshaller's ConvertToUnmanaged call. + internal static EmitMarshallerConvertToUnmanagedCallback EmitMarshallerConvertToUnmanaged(ProjectionEmitContext context, TypeSignature sig, string argName) + { + return new(context, sig, argName); + } + /// /// Emits the call to the appropriate marshaller's ConvertToManaged for a runtime class / object return value. /// @@ -38,4 +46,11 @@ internal static void EmitMarshallerConvertToManaged(IndentedTextWriter writer, P writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, sig)}.ConvertToManaged({argName})"); } + + /// + /// A callback emitting the marshaller's ConvertToManaged call. + internal static EmitMarshallerConvertToManagedCallback EmitMarshallerConvertToManaged(ProjectionEmitContext context, TypeSignature sig, string argName) + { + return new(context, sig, argName); + } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index c2f990c3a..e37cec300 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -264,9 +264,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - writer.Write($" using WindowsRuntimeObjectReferenceValue __{localName} = "); - EmitMarshallerConvertToUnmanaged(writer, context, p.Type, callName); - writer.WriteLine(";"); + EmitMarshallerConvertToUnmanagedCallback cvt = EmitMarshallerConvertToUnmanaged(context, p.Type, callName); + writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{localName} = {cvt};"); } else if (p.Type.IsNullableT()) { @@ -1242,9 +1241,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else { - writer.Write($"{callIndent}return "); - EmitMarshallerConvertToManaged(writer, context, rt, "__retval"); - writer.WriteLine(";"); + EmitMarshallerConvertToManagedCallback cvt = EmitMarshallerConvertToManaged(context, rt, "__retval"); + writer.WriteLine($"{callIndent}return {cvt};"); } } else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToManagedCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToManagedCallback.cs new file mode 100644 index 000000000..694777f34 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToManagedCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct EmitMarshallerConvertToManagedCallback( + ProjectionEmitContext context, + TypeSignature sig, + string argName) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + AbiMethodBodyFactory.EmitMarshallerConvertToManaged(writer, context, sig, argName); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToUnmanagedCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToUnmanagedCallback.cs new file mode 100644 index 000000000..3d50fa452 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/EmitMarshallerConvertToUnmanagedCallback.cs @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +/// +/// +internal readonly struct EmitMarshallerConvertToUnmanagedCallback( + ProjectionEmitContext context, + TypeSignature sig, + string argName) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + AbiMethodBodyFactory.EmitMarshallerConvertToUnmanaged(writer, context, sig, argName); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index a8bd444dc..71c477df1 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -193,9 +193,8 @@ public override unsafe void Invoke( string raw = p.Parameter.Name ?? "param"; string pname = IdentifierEscaping.EscapeIdentifier(raw); - writer.Write($" using WindowsRuntimeObjectReferenceValue __{raw} = "); - AbiMethodBodyFactory.EmitMarshallerConvertToUnmanaged(writer, context, p.Type, pname); - writer.WriteLine(";"); + EmitMarshallerConvertToUnmanagedCallback cvt = AbiMethodBodyFactory.EmitMarshallerConvertToUnmanaged(context, p.Type, pname); + writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{raw} = {cvt};"); } // For composable factories, marshal the additional `baseInterface` (which is a From eef50cda1fd7b46be0c874d63dec1354d08b26ae Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:55:22 -0700 Subject: [PATCH 060/171] R6-4: EmitUnsafeAccessors params ReadOnlySpan overload Adds an `EmitUnsafeAccessors` overload that takes a `params ReadOnlySpan<(string AccessName, string ReturnType, string FunctionName, string ExtraParams)>` parameter and an `interopType` hoisted out of the rows (since all rows in a single emit call share the same WinRT.Interop helper type). The single-item `EmitUnsafeAccessor` helper is preserved for the truly one-off case (`EmitGenericEnumerable.cs:141` emits only `GetEnumerator`). Migrates the 5 emitters that previously did 2-14 consecutive `EmitUnsafeAccessor(writer, ..., interopType, ...)` calls: - `EmitGenericEnumerator` (2 rows) - `EmitDictionary` (14 rows) - `EmitReadOnlyDictionary` (6 rows) - `EmitGenericList` (2 rows) - `EmitReadOnlyList` (2 rows) - `EmitList` (11 rows) Each emitter callsite becomes a single `EmitUnsafeAccessors` call with a literal value-tuple table whose rows can be visually scanned for accessor symmetry across emitters. `interopType` no longer appears in every row. The `params ReadOnlySpan` overload is the C# 14 idiomatic way (zero allocation: the compiler stack-allocates the span for inline-constructed literal lists). Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/MappedInterfaceStubFactory.cs | 93 ++++++++++++------- 1 file changed, 58 insertions(+), 35 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs index 7a358f01a..8b47b85e2 100644 --- a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System; using System.Collections.Generic; using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Generation; @@ -158,8 +159,9 @@ private static void EmitGenericEnumerator(IndentedTextWriter writer, ProjectionE string prefix = "IEnumeratorMethods_" + elementId + "_"; writer.WriteLine(); - EmitUnsafeAccessor(writer, "Current", t, $"{prefix}Current", interopType, ""); - EmitUnsafeAccessor(writer, "MoveNext", "bool", $"{prefix}MoveNext", interopType, ""); + EmitUnsafeAccessors(writer, interopType, [ + new("Current", t, $"{prefix}Current", ""), + new("MoveNext", "bool", $"{prefix}MoveNext", "")]); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -198,20 +200,21 @@ private static void EmitDictionary(IndentedTextWriter writer, ProjectionEmitCont string enumerableObjRefName = "_objRef_System_Collections_Generic_IEnumerable_" + IidExpressionGenerator.EscapeTypeNameForIdentifier(kvLong, stripGlobal: false) + "_"; writer.WriteLine(); - EmitUnsafeAccessor(writer, "Keys", $"ICollection<{k}>", $"{prefix}Keys", interopType, ""); - EmitUnsafeAccessor(writer, "Values", $"ICollection<{v}>", $"{prefix}Values", interopType, ""); - EmitUnsafeAccessor(writer, "Count", "int", $"{prefix}Count", interopType, ""); - EmitUnsafeAccessor(writer, "Item", v, $"{prefix}Item", interopType, $", {k} key"); - EmitUnsafeAccessor(writer, "Item", "void", $"{prefix}Item", interopType, $", {k} key, {v} value"); - EmitUnsafeAccessor(writer, "Add", "void", $"{prefix}Add", interopType, $", {k} key, {v} value"); - EmitUnsafeAccessor(writer, "ContainsKey", "bool", $"{prefix}ContainsKey", interopType, $", {k} key"); - EmitUnsafeAccessor(writer, "Remove", "bool", $"{prefix}Remove", interopType, $", {k} key"); - EmitUnsafeAccessor(writer, "TryGetValue", "bool", $"{prefix}TryGetValue", interopType, $", {k} key, out {v} value"); - EmitUnsafeAccessor(writer, "Add", "void", $"{prefix}Add", interopType, $", {kv} item"); - EmitUnsafeAccessor(writer, "Clear", "void", $"{prefix}Clear", interopType, ""); - EmitUnsafeAccessor(writer, "Contains", "bool", $"{prefix}Contains", interopType, $", {kv} item"); - EmitUnsafeAccessor(writer, "CopyTo", "void", $"{prefix}CopyTo", interopType, $", WindowsRuntimeObjectReference enumObjRef, {kv}[] array, int arrayIndex"); - EmitUnsafeAccessor(writer, "Remove", "bool", $"{prefix}Remove", interopType, $", {kv} item"); + EmitUnsafeAccessors(writer, interopType, [ + new("Keys", $"ICollection<{k}>", $"{prefix}Keys", ""), + new("Values", $"ICollection<{v}>", $"{prefix}Values", ""), + new("Count", "int", $"{prefix}Count", ""), + new("Item", v, $"{prefix}Item", $", {k} key"), + new("Item", "void", $"{prefix}Item", $", {k} key, {v} value"), + new("Add", "void", $"{prefix}Add", $", {k} key, {v} value"), + new("ContainsKey", "bool", $"{prefix}ContainsKey", $", {k} key"), + new("Remove", "bool", $"{prefix}Remove", $", {k} key"), + new("TryGetValue", "bool", $"{prefix}TryGetValue", $", {k} key, out {v} value"), + new("Add", "void", $"{prefix}Add", $", {kv} item"), + new("Clear", "void", $"{prefix}Clear", ""), + new("Contains", "bool", $"{prefix}Contains", $", {kv} item"), + new("CopyTo", "void", $"{prefix}CopyTo", $", WindowsRuntimeObjectReference enumObjRef, {kv}[] array, int arrayIndex"), + new("Remove", "bool", $"{prefix}Remove", $", {kv} item")]); // Public member emission order matches the WinRT IMap vtable order, NOT alphabetical. // GetEnumerator is NOT emitted here -- it's handled separately by IIterable's own @@ -255,12 +258,13 @@ private static void EmitReadOnlyDictionary(IndentedTextWriter writer, Projection string prefix = "IReadOnlyDictionaryMethods_" + keyId + "_" + valId + "_"; writer.WriteLine(); - EmitUnsafeAccessor(writer, "Keys", $"ICollection<{k}>", $"{prefix}Keys", interopType, ""); - EmitUnsafeAccessor(writer, "Values", $"ICollection<{v}>", $"{prefix}Values", interopType, ""); - EmitUnsafeAccessor(writer, "Count", "int", $"{prefix}Count", interopType, ""); - EmitUnsafeAccessor(writer, "Item", v, $"{prefix}Item", interopType, $", {k} key"); - EmitUnsafeAccessor(writer, "ContainsKey", "bool", $"{prefix}ContainsKey", interopType, $", {k} key"); - EmitUnsafeAccessor(writer, "TryGetValue", "bool", $"{prefix}TryGetValue", interopType, $", {k} key, out {v} value"); + EmitUnsafeAccessors(writer, interopType, [ + new("Keys", $"ICollection<{k}>", $"{prefix}Keys", ""), + new("Values", $"ICollection<{v}>", $"{prefix}Values", ""), + new("Count", "int", $"{prefix}Count", ""), + new("Item", v, $"{prefix}Item", $", {k} key"), + new("ContainsKey", "bool", $"{prefix}ContainsKey", $", {k} key"), + new("TryGetValue", "bool", $"{prefix}TryGetValue", $", {k} key, out {v} value")]); // GetEnumerator is NOT emitted here -- it's handled separately by IIterable's // EmitGenericEnumerable invocation. @@ -287,8 +291,9 @@ private static void EmitReadOnlyList(IndentedTextWriter writer, ProjectionEmitCo string prefix = "IReadOnlyListMethods_" + elementId + "_"; writer.WriteLine(); - EmitUnsafeAccessor(writer, "Count", "int", $"{prefix}Count", interopType, ""); - EmitUnsafeAccessor(writer, "Item", t, $"{prefix}Item", interopType, ", int index"); + EmitUnsafeAccessors(writer, interopType, [ + new("Count", "int", $"{prefix}Count", ""), + new("Item", t, $"{prefix}Item", ", int index")]); // GetEnumerator is NOT emitted here -- it's handled separately by IIterable's // EmitGenericEnumerable invocation. @@ -333,17 +338,18 @@ private static void EmitList(IndentedTextWriter writer, ProjectionEmitContext co string prefix = "IListMethods_" + elementId + "_"; writer.WriteLine(); - EmitUnsafeAccessor(writer, "Count", "int", $"{prefix}Count", interopType, ""); - EmitUnsafeAccessor(writer, "Item", t, $"{prefix}Item", interopType, ", int index"); - EmitUnsafeAccessor(writer, "Item", "void", $"{prefix}Item", interopType, $", int index, {t} value"); - EmitUnsafeAccessor(writer, "IndexOf", "int", $"{prefix}IndexOf", interopType, $", {t} item"); - EmitUnsafeAccessor(writer, "Insert", "void", $"{prefix}Insert", interopType, $", int index, {t} item"); - EmitUnsafeAccessor(writer, "RemoveAt", "void", $"{prefix}RemoveAt", interopType, ", int index"); - EmitUnsafeAccessor(writer, "Add", "void", $"{prefix}Add", interopType, $", {t} item"); - EmitUnsafeAccessor(writer, "Clear", "void", $"{prefix}Clear", interopType, ""); - EmitUnsafeAccessor(writer, "Contains", "bool", $"{prefix}Contains", interopType, $", {t} item"); - EmitUnsafeAccessor(writer, "CopyTo", "void", $"{prefix}CopyTo", interopType, $", {t}[] array, int arrayIndex"); - EmitUnsafeAccessor(writer, "Remove", "bool", $"{prefix}Remove", interopType, $", {t} item"); + EmitUnsafeAccessors(writer, interopType, [ + new("Count", "int", $"{prefix}Count", ""), + new("Item", t, $"{prefix}Item", ", int index"), + new("Item", "void", $"{prefix}Item", $", int index, {t} value"), + new("IndexOf", "int", $"{prefix}IndexOf", $", {t} item"), + new("Insert", "void", $"{prefix}Insert", $", int index, {t} item"), + new("RemoveAt", "void", $"{prefix}RemoveAt", ", int index"), + new("Add", "void", $"{prefix}Add", $", {t} item"), + new("Clear", "void", $"{prefix}Clear", ""), + new("Contains", "bool", $"{prefix}Contains", $", {t} item"), + new("CopyTo", "void", $"{prefix}CopyTo", $", {t}[] array, int arrayIndex"), + new("Remove", "bool", $"{prefix}Remove", $", {t} item")]); // Public member emission order matches the WinRT IVector vtable order mapped to IList, // NOT alphabetical. GetEnumerator is NOT emitted here -- it's handled separately by IIterable's @@ -382,6 +388,23 @@ private static void EmitUnsafeAccessor(IndentedTextWriter writer, string accessN writer.WriteLine(); } + /// + /// Emits a sequence of [UnsafeAccessor] static extern declarations sharing the same + /// . Each row of is forwarded to + /// . + /// Used by the collection-stub emitters which emit table-shaped sets of accessors. + /// + private static void EmitUnsafeAccessors( + IndentedTextWriter writer, + string interopType, + params ReadOnlySpan<(string AccessName, string ReturnType, string FunctionName, string ExtraParams)> accessors) + { + foreach ((string accessName, string returnType, string functionName, string extraParams) in accessors) + { + EmitUnsafeAccessor(writer, accessName, returnType, functionName, interopType, extraParams); + } + } + private static void EmitNonGenericList(IndentedTextWriter writer, string objRefName) { writer.WriteLine(); From f3eb8b6cbde529021963d77f6fea9a82aa31f121 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 14:57:49 -0700 Subject: [PATCH 061/171] R6-7: Share TypeMap attribute emission template across the 3 writers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extracts two private helpers in MetadataAttributeFactory: - `WriteTypeMapAttribute(writer, group, value, target, trimTarget)` - emits one `[assembly: TypeMap(value, target, trimTarget)]` line preceded by a blank line. Used by the 2 TypeMap emitters ( `WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute` and `WriteWinRTComWrappersTypeMapGroupAssemblyAttribute`). - `WriteTypeMapAssociation(writer, group, source, proxy)` - emits one `[assembly: TypeMapAssociation(source, proxy)]` line preceded by a blank line. Used by the 3 places that emit the association (component-mode branches of the 2 TypeMap emitters + `WriteWinRTIdicTypeMapGroupAssemblyAttribute`). The interesting logic is now visible at each callsite (skip rules, component-mode predicates, value vs. target slot derivation); the shared `[assembly: ...]` template lives in one place. Each emitter shrinks by ~10 lines of repeated multiline-raw-string boilerplate. R6-7b (the TypeMapEmissionPlan table for ProjectionGenerator.Namespace.cs:62-99) is deferred — the dispatch switch is simple enough as-is and a data table would obscure the per-category ordering rules without significant LOC savings. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/MetadataAttributeFactory.cs | 72 ++++++++++--------- 1 file changed, 37 insertions(+), 35 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 410b5ddf7..1aad438ec 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -302,26 +302,15 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent string projectionName = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true).Format(); // The 'target:' slot is the ABI typedef name in component mode, otherwise the projected name. - WriteTypedefNameWithTypeParamsCallback target = context.Settings.Component + string target = (context.Settings.Component ? TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true) - : TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + : TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true)).Format(); - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [assembly: TypeMap( - value: "{{projectionName}}", - target: typeof({{target}}), - trimTarget: typeof({{projectionName}}))] - """); + WriteTypeMapAttribute(writer, "WindowsRuntimeMetadataTypeMapGroup", $"\"{projectionName}\"", $"typeof({target})", $"typeof({projectionName})"); if (context.Settings.Component) { - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [assembly: TypeMapAssociation( - source: typeof({{projectionName}}), - proxy: typeof({{target}}))] - """); + WriteTypeMapAssociation(writer, "WindowsRuntimeMetadataTypeMapGroup", $"typeof({projectionName})", $"typeof({target})"); writer.WriteLine(); } } @@ -342,29 +331,18 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe string value = isValueType ? $"Windows.Foundation.IReference`1<{projectionName}>" : projectionName; // The 'target:' slot is the ABI typedef name in component mode, otherwise the projected name. - WriteTypedefNameWithTypeParamsCallback target = context.Settings.Component + string target = (context.Settings.Component ? TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true) - : TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true); + : TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.NonProjected, true)).Format(); - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [assembly: TypeMap( - value: "{{value}}", - target: typeof({{target}}), - trimTarget: typeof({{projectionName}}))] - """); + WriteTypeMapAttribute(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"\"{value}\"", $"typeof({target})", $"typeof({projectionName})"); // For non-interface, non-struct authored types, emit proxy association. TypeCategory cat = TypeCategorization.GetCategory(type); if (cat is not (TypeCategory.Interface or TypeCategory.Struct) && context.Settings.Component) { - writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [assembly: TypeMapAssociation( - source: typeof({{projectionName}}), - proxy: typeof({{target}}))] - """); + WriteTypeMapAssociation(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"typeof({projectionName})", $"typeof({target})"); writer.WriteLine(); } } @@ -391,16 +369,40 @@ public static void WriteWinRTIdicTypeMapGroupAssemblyAttribute(IndentedTextWrite return; } - WriteTypedefNameWithTypeParamsCallback source = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true); - WriteTypedefNameWithTypeParamsCallback proxy = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true); + string source = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, true).Format(); + string proxy = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true).Format(); + WriteTypeMapAssociation(writer, "DynamicInterfaceCastableImplementationTypeMapGroup", $"typeof({source})", $"typeof({proxy})"); + writer.WriteLine(); + } + + /// + /// Emits a single [assembly: TypeMap<>(value, target, trimTarget)] line + /// preceded by a blank line. Used by the three Write*TypeMapGroupAssemblyAttribute helpers. + /// + private static void WriteTypeMapAttribute(IndentedTextWriter writer, string group, string value, string target, string trimTarget) + { writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - [assembly: TypeMapAssociation( - source: typeof({{source}}), - proxy: typeof({{proxy}}))] + [assembly: TypeMap<{{group}}>( + value: {{value}}, + target: {{target}}, + trimTarget: {{trimTarget}})] """); + } + + /// + /// Emits a single [assembly: TypeMapAssociation<>(source, proxy)] line + /// preceded by a blank line. Used by the three Write*TypeMapGroupAssemblyAttribute helpers. + /// + private static void WriteTypeMapAssociation(IndentedTextWriter writer, string group, string source, string proxy) + { writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" + [assembly: TypeMapAssociation<{{group}}>( + source: {{source}}, + proxy: {{proxy}})] + """); } /// From 72773269c9c35ccb14fb94e1b1cecc2dc12df632 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 15:02:56 -0700 Subject: [PATCH 062/171] R6-12: Property/event accessor multiline consolidation (partial sweep) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Consolidates the static-factory property and event emitters in ComponentFactory into single multiline raw-string templates: - `WriteStaticFactoryProperty`: precomputes `propType` (via the new `GetFactoryPropertyType` string helper) and `getterLine` (an empty string when no getter is present), then emits either a single expression-body line (no setter) or a single multiline block (with the conditional getter line collapsed by the blank-line suppression when empty). - `WriteStaticFactoryEvent`: precomputes `evtType` once and emits a single multiline event-accessor block. The pattern follows the established model from commit 6bc25a28 (event-accessor body consolidation in ClassFactory). Other R6-12 candidate sites (ClassFactory static property emitter, instance/ explicit-interface property forwarders in ClassMembersFactory, event-source CompareExchange) are left for a future pass — their platform-attribute and getter/setter interaction patterns deserve more care than fits in this commit. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ComponentFactory.cs | 41 ++++++++----------- 1 file changed, 16 insertions(+), 25 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index fde681252..4c5e5c4ff 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -200,29 +200,24 @@ private static void WriteStaticFactoryProperty(IndentedTextWriter writer, Projec { string propName = prop.Name?.Value ?? string.Empty; (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + string propType = GetFactoryPropertyType(context, prop); + // Single-line form when no setter is present. if (setter is null) { writer.WriteLine(); - writer.Write("public "); - WriteFactoryPropertyType(writer, context, prop); - writer.WriteLine($" {propName} => {projectedTypeName}.{propName};"); + writer.WriteLine($"public {propType} {propName} => {projectedTypeName}.{propName};"); return; } + string getterLine = getter is not null + ? $"get => {projectedTypeName}.{propName};" + : string.Empty; writer.WriteLine(); - writer.Write("public "); - WriteFactoryPropertyType(writer, context, prop); writer.WriteLine(isMultiline: true, $$""" - {{propName}} + public {{propType}} {{propName}} { - """); - if (getter is not null) - { - writer.WriteLine($"get => {projectedTypeName}.{propName};"); - } - - writer.WriteLine(isMultiline: true, $$""" + {{getterLine}} set => {{projectedTypeName}}.{{propName}} = value; } """); @@ -234,17 +229,13 @@ private static void WriteStaticFactoryProperty(IndentedTextWriter writer, Projec private static void WriteStaticFactoryEvent(IndentedTextWriter writer, ProjectionEmitContext context, EventDefinition evt, string projectedTypeName) { string evtName = evt.Name?.Value ?? string.Empty; - writer.WriteLine(); - writer.Write("public event "); - - if (evt.EventType is not null) - { - TypeSemantics evtSemantics = TypeSemanticsFactory.GetFromTypeDefOrRef(evt.EventType); - TypedefNameWriter.WriteTypeName(writer, context, evtSemantics, TypedefNameType.Projected, false); - } + string evtType = evt.EventType is null + ? string.Empty + : TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.GetFromTypeDefOrRef(evt.EventType), TypedefNameType.Projected, false).Format(); + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - {{evtName}} + public event {{evtType}} {{evtName}} { add => {{projectedTypeName}}.{{evtName}} += value; remove => {{projectedTypeName}}.{{evtName}} -= value; @@ -276,17 +267,17 @@ public static void WriteFactoryReturnType(IndentedTextWriter writer, ProjectionE TypedefNameWriter.WriteTypeName(writer, context, semantics, TypedefNameType.Projected, true); } - private static void WriteFactoryPropertyType(IndentedTextWriter writer, ProjectionEmitContext context, PropertyDefinition prop) + private static string GetFactoryPropertyType(ProjectionEmitContext context, PropertyDefinition prop) { TypeSignature? sig = prop.Signature?.ReturnType; if (sig is null) { - writer.Write("object"); return; + return "object"; } TypeSemantics semantics = TypeSemanticsFactory.Get(sig); - TypedefNameWriter.WriteTypeName(writer, context, semantics, TypedefNameType.Projected, true); + return TypedefNameWriter.WriteTypeName(context, semantics, TypedefNameType.Projected, true).Format(); } /// From 0de9413d976131aa861d9ff5c20de8a9f34137db Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 15:04:33 -0700 Subject: [PATCH 063/171] R6-27: Collapse ProjectionFileBuilder.WriteDelegate into one declaration template Consolidates the 11-chunk emission in `WriteDelegate` into a single multiline raw-string template. Locals are precomputed for each interpolation hole (metadata attribute, custom attrs, com-wrappers attr, conditional Guid attribute via the new `IidExpressionGenerator.FormatGuid` helper, return type, typedef name, type params, parameter list), then a single `writer.WriteLine(isMultiline: true, ...)` emits the full delegate declaration in source shape. Adds `IidExpressionGenerator.FormatGuid(type, lowerCase)` to materialize the GUID as a string so it can be embedded inside a string local without going through a writer. The Guid attribute is conditional on `!ReferenceProjection`; the blank-line suppression in the writer's interpolated-string handler collapses the template line when `guidAttr` is empty. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 38 +++++++++---------- .../Helpers/IidExpressionGenerator.cs | 12 ++++++ 2 files changed, 30 insertions(+), 20 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 896464bd1..ca68a619b 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -359,27 +359,25 @@ public static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitContex MethodSignatureInfo sig = new(invoke); - writer.WriteLine(); - MetadataAttributeFactory.WriteWinRTMetadataAttribute(writer, type, context.Cache); - CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); - MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(writer, context, type); - - if (!context.Settings.ReferenceProjection) - { - // GUID attribute - writer.Write("[Guid(\""); - IidExpressionGenerator.WriteGuid(writer, type, false); - writer.WriteLine("\")]"); - } + WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); + WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, false); + WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); + string guidAttr = context.Settings.ReferenceProjection + ? string.Empty + : $"[Guid(\"{IidExpressionGenerator.FormatGuid(type, lowerCase: false)}\")]"; + WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); + WriteTypedefNameCallback typedefName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, false); + WriteTypeParamsCallback typeParams = TypedefNameWriter.WriteTypeParams(type); + WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); - writer.Write($"{context.Settings.InternalAccessibility} delegate "); - MethodFactory.WriteProjectionReturnType(writer, context, sig); - writer.Write(" "); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.Projected, false); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write("("); - MethodFactory.WriteParameterList(writer, context, sig); - writer.WriteLine(");"); + writer.WriteLine(); + writer.WriteLine(isMultiline: true, $$""" + {{metadataAttr}} + {{customAttrs}} + {{comWrappersAttr}} + {{guidAttr}} + {{context.Settings.InternalAccessibility}} delegate {{ret}} {{typedefName}}{{typeParams}}({{parms}}); + """); } /// diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index d65d8235f..26e2f651f 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -119,6 +119,9 @@ public static (uint Data1, ushort Data2, ushort Data3, byte[] Data4)? GetGuidFie }; } + /// + /// Writes the GUID for in canonical hyphenated string form. + /// /// /// Writes the GUID for in canonical hyphenated string form. /// @@ -142,6 +145,15 @@ public static void WriteGuid(IndentedTextWriter writer, TypeDefinition type, boo } } + /// + /// The formatted GUID as a string. + public static string FormatGuid(TypeDefinition type, bool lowerCase) + { + using IndentedTextWriterOwner owner = IndentedTextWriterPool.GetOrCreate(); + WriteGuid(owner.Writer, type, lowerCase); + return owner.Writer.ToString(); + } + /// /// Writes the GUID bytes for as a hex byte list. /// From f402e3c71a3a08bcf9aea7558bbaedf80136db31 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 15:05:34 -0700 Subject: [PATCH 064/171] R6-28: AbiStructFactory field-type helper Extracts the 5-branch field-type selection (string/Nullable -> `void*`, mapped value type -> ABI type, nested non-blittable struct -> ABI typedef, default -> projected C# type) from the inline field-emission loop into a private `GetAbiFieldType` helper that returns the type string. Each field-emission iteration now reads as a single line: `writer.WriteLine($`"public {fieldType} {fieldName};")`. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiStructFactory.cs | 60 +++++++++++-------- 1 file changed, 35 insertions(+), 25 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index 1605b13db..bcad0e219 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -58,31 +58,8 @@ public static void WriteAbiStruct(IndentedTextWriter writer, ProjectionEmitConte } TypeSignature ft = field.Signature.FieldType; - writer.Write("public "); - // Truth uses void* for string and Nullable fields, the ABI type for mapped value - // types (DateTime/TimeSpan), and the projected type for everything else (including - // enums and bool — their C# layout matches the WinRT ABI directly). - if (ft.IsString() || AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out _)) - { - writer.Write("void*"); - } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(ft)) - { - writer.Write(AbiTypeHelpers.GetMappedAbiTypeName(ft)); - } - else if (ft is TypeDefOrRefSignature tdr - && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, tdr) is TypeDefinition fieldTd - && TypeCategorization.GetCategory(fieldTd) == TypeCategory.Struct - && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldTd)) - { - TypedefNameWriter.WriteTypedefName(writer, context, fieldTd, TypedefNameType.ABI, false); - } - else - { - MethodFactory.WriteProjectedSignature(writer, context, ft, false); - } - - writer.WriteLine($" {field.Name?.Value ?? string.Empty};"); + string fieldType = GetAbiFieldType(context, ft); + writer.WriteLine($"public {fieldType} {field.Name?.Value ?? string.Empty};"); } } writer.WriteLine(); @@ -97,4 +74,37 @@ public static void WriteAbiStruct(IndentedTextWriter writer, ProjectionEmitConte StructEnumMarshallerFactory.WriteStructEnumMarshallerClass(writer, context, type); ReferenceImplFactory.WriteReferenceImpl(writer, context, type); } + + /// + /// Returns the projected ABI field type for an unblittable / unmapped struct field. + /// Truth uses void* for string and Nullable<T> fields, the mapped ABI + /// type for mapped value types (DateTime/TimeSpan), the ABI typedef for nested non-blittable + /// structs, and the projected C# type for everything else (including enums and bool — their + /// C# layout matches the WinRT ABI directly). + /// + private static string GetAbiFieldType(ProjectionEmitContext context, TypeSignature ft) + { + if (ft.IsString() || AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out _)) + { + return "void*"; + } + + if (context.AbiTypeShapeResolver.IsMappedAbiValueType(ft)) + { + return AbiTypeHelpers.GetMappedAbiTypeName(ft); + } + + if (ft is TypeDefOrRefSignature tdr + && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, tdr) is TypeDefinition fieldTd + && TypeCategorization.GetCategory(fieldTd) == TypeCategory.Struct + && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldTd)) + { + return TypedefNameWriter.WriteTypedefName(context, fieldTd, TypedefNameType.ABI, false).Format(); + } + + // Default: emit the projected C# type via the signature writer. + using IndentedTextWriterOwner owner = IndentedTextWriterPool.GetOrCreate(); + MethodFactory.WriteProjectedSignature(owner.Writer, context, ft, false); + return owner.Writer.ToString(); + } } From 5095be37ec15f03b5f1ff03e5835ef254070a06c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 15:20:01 -0700 Subject: [PATCH 065/171] R6-10a: Extract GetInstanceFields helper in StructEnumMarshallerFactory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The 4 inline `foreach (field in type.Fields) { if (field.IsStatic || field.Signature is null) continue; ... }` patterns in StructEnumMarshallerFactory (at L41, L87, L148, L207) were duplicating the same field-guard logic. Extract a private `GetInstanceFields` iterator that internally skips static fields and fields with no signature; each of the 4 callers becomes `foreach (field in GetInstanceFields(type))`. R6-10b (per-direction conversion expression helper) is deferred — the 5-way ConvertToUnmanaged/ConvertToManaged dispatch chains have subtle per-direction differences (HResult, Nullable) that need careful parameterization. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/StructEnumMarshallerFactory.cs | 54 +++++++++---------- 1 file changed, 26 insertions(+), 28 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 31e2a2136..26a828e02 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System.Collections.Generic; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Factories.Callbacks; @@ -16,6 +17,23 @@ namespace WindowsRuntime.ProjectionWriter.Factories; /// internal static class StructEnumMarshallerFactory { + /// + /// Returns the instance fields of (skipping static fields and fields + /// without a signature). Used by the 4 places in this file that loop over a struct's fields. + /// + private static IEnumerable GetInstanceFields(TypeDefinition type) + { + foreach (FieldDefinition field in type.Fields) + { + if (field.IsStatic || field.Signature is null) + { + continue; + } + + yield return field; + } + } + /// /// Writes a marshaller class for a struct or enum. /// @@ -36,14 +54,9 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P if (isComplexStruct) { - foreach (FieldDefinition field in type.Fields) + foreach (FieldDefinition field in GetInstanceFields(type)) { - if (field.IsStatic || field.Signature is null) - { - continue; - } - - TypeSignature ft = field.Signature.FieldType; + TypeSignature ft = field.Signature!.FieldType; if (AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out _)) { @@ -82,15 +95,10 @@ public static unsafe class {{nameStripped}}Marshaller return new() { """); bool first = true; - foreach (FieldDefinition field in type.Fields) + foreach (FieldDefinition field in GetInstanceFields(type)) { - if (field.IsStatic || field.Signature is null) - { - continue; - } - string fname = field.Name?.Value ?? ""; - TypeSignature ft = field.Signature.FieldType; + TypeSignature ft = field.Signature!.FieldType; writer.WriteLineIf(!first, ","); @@ -143,15 +151,10 @@ public static unsafe class {{nameStripped}}Marshaller return new {{projected}}{{(useObjectInitializer ? "(){" : "(")}} """); first = true; - foreach (FieldDefinition field in type.Fields) + foreach (FieldDefinition field in GetInstanceFields(type)) { - if (field.IsStatic || field.Signature is null) - { - continue; - } - string fname = field.Name?.Value ?? ""; - TypeSignature ft = field.Signature.FieldType; + TypeSignature ft = field.Signature!.FieldType; writer.WriteLineIf(!first, ","); @@ -202,15 +205,10 @@ public static unsafe class {{nameStripped}}Marshaller public static void Dispose({{abi}} value) { """); - foreach (FieldDefinition field in type.Fields) + foreach (FieldDefinition field in GetInstanceFields(type)) { - if (field.IsStatic || field.Signature is null) - { - continue; - } - string fname = field.Name?.Value ?? ""; - TypeSignature ft = field.Signature.FieldType; + TypeSignature ft = field.Signature!.FieldType; if (ft.IsString()) { From f3c28af34ba97dd52679aa9df1897a01a8b2755f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 15:21:50 -0700 Subject: [PATCH 066/171] R6-18b: Reuse AbiTypeHelpers.GetAbiLocalTypeName at the 2 DoAbi receive-array sites The two `elementAbi = sza.BaseType.IsString() || IsRuntimeClassOrInterface(...) || IsObject() ? "void*" : IsComplexStruct(...) ? GetAbiStructTypeName(...) : IsBlittableStruct(...) ? GetBlittableStructAbiType(...) : GetAbiPrimitiveType(...)` chains in `AbiMethodBodyFactory.DoAbi.cs` (at L134 for pass-array param preamble and L144 for receive-array return preamble) are subsumed by the existing `AbiTypeHelpers.GetAbiLocalTypeName` (the additional branches in the helper - `IsGenericInstance` / `IsSystemType` / `IsHResultException` / `IsMappedAbiValueType` - don't fire for SZ-array element types in practice). Verified byte-identical for all 3 reference scenarios (763 generated .cs files), confirming the additional helper branches are unreachable in this context. The two `RcwCaller.cs` sites (L399, L477) already use `GetAbiLocalTypeName` per the prior round's d36e3b0f extraction. R6-18 main (the `InlineArray16` scratch-buffer helper extraction) and R6-18a (the UnsafeAccessor declaration shapes) are deferred - both involve more intricate emission state than fits in this commit. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 29dae4655..8d7b8df5a 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -124,13 +124,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); - string elementAbi = sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject() - ? "void*" - : context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType) - : context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType); + string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, sza.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern void ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); @@ -141,13 +135,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (returnIsReceiveArrayDoAbi && rt is SzArrayTypeSignature retSzHoist) { WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSzHoist.BaseType)); - string elementAbi = retSzHoist.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSzHoist.BaseType) || retSzHoist.BaseType.IsObject() - ? "void*" - : context.AbiTypeShapeResolver.IsComplexStruct(retSzHoist.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSzHoist.BaseType) - : context.AbiTypeShapeResolver.IsBlittableStruct(retSzHoist.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSzHoist.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSzHoist.BaseType); + string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, retSzHoist.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(retSzHoist.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] From 48e22ee734117f97cf50289a441c795d2233d1dd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:23:51 -0700 Subject: [PATCH 067/171] R7-1: TypeSignature.IsAbiRefLike + IsAbiArrayElementRefLike extensions Adds two named predicates on TypeSignature that capture the "void*-shape" disjunction: - `IsAbiRefLike(AbiTypeShapeResolver)`: 4-way variant for parameter/return types (IsString || IsRuntimeClassOrInterface || IsObject || IsGenericInstance). - `IsAbiArrayElementRefLike(AbiTypeShapeResolver)`: 3-way variant for SZ-array element types, omitting IsGenericInstance (generic instances cannot appear as array elements in metadata). The two-predicate split prevents the silent drift hazard the merged R7 report flagged: the disjunction appeared at 16 sites with some including IsGenericInstance and some not. Naming both variants explicitly documents the distinction. Migrates 14 callsites: - 4-way (IsAbiRefLike): AbiInterfaceFactory.cs:101, AbiMethodBodyFactory.RcwCaller.cs:73,156, AbiTypeHelpers.AbiTypeNames.cs:32 - 4 sites - 3-way (IsAbiArrayElementRefLike): AbiMethodBodyFactory.DoAbi.cs:31,596, AbiMethodBodyFactory.RcwCaller.cs:49,123,187,1050,1176,1197,1517,1554 - 10 sites The 2 unmigrated occurrences (RcwCaller.cs:527 and AbiTypeHelpers.cs:243) embed the disjunction inside larger predicates (IsSystemType, IsComplexStruct, etc.) that don't fit either variant cleanly. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeSignatureExtensions.cs | 38 +++++++++++++++++++ .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 4 +- .../AbiMethodBodyFactory.RcwCaller.cs | 22 +++++------ .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 +- 5 files changed, 53 insertions(+), 15 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index c04801bec..9d55e7cca 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -3,6 +3,7 @@ using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Resolvers; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; using static WindowsRuntime.ProjectionWriter.References.WellKnownTypeNames; @@ -173,5 +174,42 @@ public bool IsByRefType() } return cur is ByReferenceTypeSignature; } + + /// + /// Returns whether the signature has the "ABI reference-pointer" shape: it crosses the + /// ABI as a void* / IInspectable*. That covers (HSTRING), + /// any WinRT runtime class or interface (resolved via ), + /// , and any generic instance (e.g. IList<T>). + /// + /// The active (needed for runtime-class/interface resolution). + /// if the signature flows as a void* across the ABI; otherwise . + /// + /// Use this variant for parameter/return types. For SZ-array element types (where generic + /// instances cannot appear as elements), use instead. + /// + public bool IsAbiRefLike(AbiTypeShapeResolver resolver) + { + return (sig is CorLibTypeSignature corlibStr && corlibStr.ElementType == ElementType.String) + || resolver.IsRuntimeClassOrInterface(sig!) + || (sig is CorLibTypeSignature corlibObj && corlibObj.ElementType == ElementType.Object) + || sig is GenericInstanceTypeSignature; + } + + /// + /// Returns whether the signature has the "ABI array-element reference-pointer" shape: + /// it crosses the ABI as a void* when carried as an element of an SZ-array. + /// That covers , WinRT runtime classes/interfaces, and + /// — the 3-way variant of + /// without the IsGenericInstance case, because generic instances cannot + /// appear as array elements in metadata. + /// + /// The active (needed for runtime-class/interface resolution). + /// if the signature flows as a void* when used as an SZ-array element; otherwise . + public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) + { + return (sig is CorLibTypeSignature corlibStr && corlibStr.ElementType == ElementType.String) + || resolver.IsRuntimeClassOrInterface(sig!) + || (sig is CorLibTypeSignature corlibObj && corlibObj.ElementType == ElementType.Object); + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index f30ddb15e..0fc1f393c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -98,7 +98,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj // Special case: 'out T[]' is a ReceiveArray ABI signature: (uint* size, T** data). if (br.BaseType is SzArrayTypeSignature brSz && cat == ParameterCategory.ReceiveArray) { - bool isRefElemBr = brSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(brSz.BaseType) || brSz.BaseType.IsObject() || brSz.BaseType.IsGenericInstance(); + bool isRefElemBr = brSz.BaseType.IsAbiRefLike(context.AbiTypeShapeResolver); WriteAbiTypeCallback elemAbi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(brSz.BaseType)); if (includeParamNames) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 8d7b8df5a..b38652cdb 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -28,7 +28,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection bool returnIsReceiveArrayDoAbi = rt is SzArrayTypeSignature retSzAbi && (context.AbiTypeShapeResolver.IsBlittablePrimitive(retSzAbi.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(retSzAbi.BaseType) - || retSzAbi.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSzAbi.BaseType) || retSzAbi.BaseType.IsObject() + || retSzAbi.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || context.AbiTypeShapeResolver.IsComplexStruct(retSzAbi.BaseType)); bool returnIsHResultExceptionDoAbi = rt is not null && rt.IsHResultException(); bool returnIsString = rt is not null && rt.IsString(); @@ -593,7 +593,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string dataParamType; string dataCastType; - if (szFA.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(szFA.BaseType) || szFA.BaseType.IsObject()) + if (szFA.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) { dataParamType = "void** data"; dataCastType = "(void**)"; diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index e37cec300..f48f4c38f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -46,7 +46,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; bool returnIsReceiveArray = rt is SzArrayTypeSignature retSzCheck && (context.AbiTypeShapeResolver.IsBlittablePrimitive(retSzCheck.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(retSzCheck.BaseType) - || retSzCheck.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSzCheck.BaseType) || retSzCheck.BaseType.IsObject() + || retSzCheck.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || context.AbiTypeShapeResolver.IsComplexStruct(retSzCheck.BaseType) || retSzCheck.BaseType.IsHResultException() || context.AbiTypeShapeResolver.IsMappedAbiValueType(retSzCheck.BaseType)); @@ -70,7 +70,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); _ = fp.Append(", "); - if (uOut.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uOut) || uOut.IsObject() || uOut.IsGenericInstance()) + if (uOut.IsAbiRefLike(context.AbiTypeShapeResolver)) { _ = fp.Append("void**"); } @@ -120,7 +120,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); _ = fp.Append(", uint*, "); - if (sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject()) + if (sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) { _ = fp.Append("void*"); } @@ -153,7 +153,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append("global::ABI.System.Exception"); } - else if (p.Type.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject() || p.Type.IsGenericInstance()) + else if (p.Type.IsAbiRefLike(context.AbiTypeShapeResolver)) { _ = fp.Append("void*"); } @@ -184,7 +184,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; _ = fp.Append(", uint*, "); - if (retSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSz.BaseType) || retSz.BaseType.IsObject()) + if (retSz.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) { _ = fp.Append("void*"); } @@ -524,7 +524,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - if (uOut.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uOut) || uOut.IsObject() || uOut.IsSystemType() || context.AbiTypeShapeResolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) + if (uOut.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || uOut.IsSystemType() || context.AbiTypeShapeResolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) { hasOutNeedsCleanup = true; break; @@ -1047,7 +1047,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string dataParamType; string dataCastType; - if (szFA.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(szFA.BaseType) || szFA.BaseType.IsObject()) + if (szFA.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) { dataParamType = "void** data"; dataCastType = "(void**)"; @@ -1173,7 +1173,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Element ABI type: void* for ref types (string/runtime class/object); ABI struct // type for complex structs (e.g. authored BasicStruct); blittable struct ABI for // blittable structs; primitive ABI otherwise. - string elementAbi = sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject() + string elementAbi = sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) ? "void*" : context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType) @@ -1194,7 +1194,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSz.BaseType)); - string elementAbi = retSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSz.BaseType) || retSz.BaseType.IsObject() + string elementAbi = retSz.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) ? "void*" : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType) @@ -1514,7 +1514,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. (Same categorization as the ConvertToManaged_ path.) - string elementAbi = sza.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sza.BaseType) || sza.BaseType.IsObject() + string elementAbi = sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) ? "void*" : context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType) @@ -1551,7 +1551,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else if (returnIsReceiveArray) { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt!; - string elementAbi = retSz.BaseType.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(retSz.BaseType) || retSz.BaseType.IsObject() + string elementAbi = retSz.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) ? "void*" : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 9f85a3d0c..7d3a3c055 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -29,7 +29,7 @@ internal static partial class AbiTypeHelpers /// The ABI C# type name as a string (no trailing punctuation). internal static string GetAbiLocalTypeName(IndentedTextWriter writer, ProjectionEmitContext context, TypeSignature sig) { - if (sig.IsString() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(sig) || sig.IsObject() || sig.IsGenericInstance()) + if (sig.IsAbiRefLike(context.AbiTypeShapeResolver)) { return "void*"; } From 1df098c4c539e9848826225fcef4488de2e2aa9b Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:25:04 -0700 Subject: [PATCH 068/171] R7-2: AbiTypeShapeResolver.IsBlittableAbiElement helper Adds a named predicate `IsBlittableAbiElement(TypeSignature)` on AbiTypeShapeResolver that collapses the `IsBlittablePrimitive(X) || IsBlittableStruct(X)` disjunction. Migrates 17 callsites (positive + 1 negative form) across: - AbiMethodBodyFactory.DoAbi.cs (6) - AbiMethodBodyFactory.RcwCaller.cs (7) - ConstructorFactory.FactoryCallbacks.cs (4) The 1 unmigrated occurrence at DoAbi.cs:454 includes `|| IsEnumType(uRef)` as a third clause - different shape, doesn't fit this 2-way predicate. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 12 ++++++------ .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 14 +++++++------- .../ConstructorFactory.FactoryCallbacks.cs | 8 ++++---- .../Resolvers/AbiTypeShapeResolver.cs | 9 +++++++++ 4 files changed, 26 insertions(+), 17 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index b38652cdb..156fa16fd 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -27,7 +27,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection TypeSignature? rt = sig.ReturnType; bool returnIsReceiveArrayDoAbi = rt is SzArrayTypeSignature retSzAbi - && (context.AbiTypeShapeResolver.IsBlittablePrimitive(retSzAbi.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(retSzAbi.BaseType) + && (context.AbiTypeShapeResolver.IsBlittableAbiElement(retSzAbi.BaseType) || retSzAbi.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || context.AbiTypeShapeResolver.IsComplexStruct(retSzAbi.BaseType)); bool returnIsHResultExceptionDoAbi = rt is not null && rt.IsHResultException(); @@ -257,7 +257,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.Parameter.Name ?? "param"; string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); - bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittablePrimitive(sz.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(sz.BaseType); + bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(sz.BaseType); if (isBlittableElem) { @@ -300,7 +300,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -577,7 +577,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } // Blittable element types: Span wraps the native buffer; no copy-back needed. - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szFA.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szFA.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szFA.BaseType)) { continue; } @@ -711,7 +711,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -741,7 +741,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index f48f4c38f..9238e8ade 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -45,7 +45,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec bool returnIsBlittableStruct = returnShape == AbiTypeShapeKind.BlittableStruct; bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; bool returnIsReceiveArray = rt is SzArrayTypeSignature retSzCheck - && (context.AbiTypeShapeResolver.IsBlittablePrimitive(retSzCheck.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(retSzCheck.BaseType) + && (context.AbiTypeShapeResolver.IsBlittableAbiElement(retSzCheck.BaseType) || retSzCheck.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || context.AbiTypeShapeResolver.IsComplexStruct(retSzCheck.BaseType) || retSzCheck.BaseType.IsHResultException() @@ -418,7 +418,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -547,7 +547,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if ((cat is ParameterCategory.PassArray or ParameterCategory.FillArray) && p.Type is SzArrayTypeSignature szArrCheck - && !context.AbiTypeShapeResolver.IsBlittablePrimitive(szArrCheck.BaseType) && !context.AbiTypeShapeResolver.IsBlittableStruct(szArrCheck.BaseType) + && !context.AbiTypeShapeResolver.IsBlittableAbiElement(szArrCheck.BaseType) && !context.AbiTypeShapeResolver.IsMappedAbiValueType(szArrCheck.BaseType)) { hasNonBlittablePassArray = true; @@ -726,7 +726,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else if (isPassArray) { TypeSignature elemT = ((SzArrayTypeSignature)p.Type).BaseType; - bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittablePrimitive(elemT) || context.AbiTypeShapeResolver.IsBlittableStruct(elemT); + bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(elemT); bool isStringElem = elemT.IsString(); if (isBlittableElem) @@ -804,7 +804,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -1031,7 +1031,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szFA.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szFA.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szFA.BaseType)) { continue; } @@ -1353,7 +1353,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 71c477df1..3e30388b9 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -260,7 +260,7 @@ public override unsafe void Invoke( continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -376,7 +376,7 @@ public override unsafe void Invoke( else if (isArr) { TypeSignature elemT = ((SzArrayTypeSignature)p.Type).BaseType; - bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittablePrimitive(elemT) || context.AbiTypeShapeResolver.IsBlittableStruct(elemT); + bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(elemT); bool isStringElem = elemT.IsString(); if (isBlittableElem) @@ -437,7 +437,7 @@ public override unsafe void Invoke( continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -599,7 +599,7 @@ public override unsafe void Invoke( continue; } - if (context.AbiTypeShapeResolver.IsBlittablePrimitive(szArr.BaseType) || context.AbiTypeShapeResolver.IsBlittableStruct(szArr.BaseType)) + if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs index 31c92c8bc..15d50fa2b 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs @@ -102,6 +102,15 @@ public bool IsRuntimeClassOrInterface(TypeSignature signature) public bool IsMappedAbiValueType(TypeSignature signature) => Resolve(signature).Kind == AbiTypeShapeKind.MappedAbiValueType; + /// + /// Returns whether is a blittable element shape suitable for + /// direct pinning when carried as an SZ-array element (a blittable primitive or a blittable struct). + /// + /// The type signature to classify. + /// when the type is blittable in the array-element sense; otherwise . + public bool IsBlittableAbiElement(TypeSignature signature) + => IsBlittablePrimitive(signature) || IsBlittableStruct(signature); + /// /// Inner classification routine. Returns the resolved for /// ; returns when the From 61e9d455580caa1db36731e9e1b3f1ab70b161bd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:26:23 -0700 Subject: [PATCH 069/171] R7-4: ParameterInfo.GetRawName extension Adds `GetRawName(this ParameterInfo, string defaultName = "param")` as the companion to the existing `GetEscapedName`. Returns the un-escaped metadata name (or the fallback), used for derived identifiers like `__{rawName}` fixed-block locals and marshalling-state field names. Mechanically migrates all 37 inline `parameter.Parameter.Name ?? "param"` (and the 2 `?? "p"` variants) sites across AbiInterfaceFactory.cs, AbiMethodBodyFactory.{DoAbi,RcwCaller}.cs, ConstructorFactory.{AttributedTypes,Composable,FactoryCallbacks}.cs, MethodFactory.cs, and Helpers/AbiTypeHelpers.cs. Output is byte-identical for all 3 reference scenarios (763 generated .cs files). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 36 +++++++++---------- .../AbiMethodBodyFactory.RcwCaller.cs | 2 +- .../ConstructorFactory.AttributedTypes.cs | 2 +- .../ConstructorFactory.Composable.cs | 2 +- .../ConstructorFactory.FactoryCallbacks.cs | 24 ++++++------- .../Factories/MethodFactory.cs | 2 +- .../Helpers/AbiTypeHelpers.cs | 4 +-- .../Models/ParameterInfoExtensions.cs | 15 ++++++++ 9 files changed, 52 insertions(+), 37 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 0fc1f393c..c3333d2af 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -78,7 +78,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj writer.Write(", "); ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - string paramName = p.Parameter.Name ?? "param"; + string paramName = p.GetRawName(); WriteEscapedIdentifierCallback name = IdentifierEscaping.WriteEscapedIdentifier(paramName); if (p.Type is SzArrayTypeSignature) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 156fa16fd..3117ee9af 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -96,7 +96,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" @@ -119,7 +119,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); @@ -189,7 +189,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"*{ptr} = default;"); } @@ -203,7 +203,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); // Use the projected (non-ABI) type for the local variable. // Strip ByRef and CustomModifier wrappers to get the underlying base type. TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); @@ -224,7 +224,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); @@ -254,7 +254,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(sz.BaseType); @@ -305,7 +305,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); // For complex structs, the data param is the ABI struct pointer (e.g. BasicStruct*). @@ -343,7 +343,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (p.Type.IsNullableT()) { // Nullable param (server-side): use Marshaller.UnboxToManaged. - string rawName = p.Parameter.Name ?? "param"; + string rawName = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(rawName); TypeSignature inner = p.Type.GetNullableInnerType()!; string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); @@ -351,7 +351,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else if (p.Type.IsGenericInstance()) { - string rawName = p.Parameter.Name ?? "param"; + string rawName = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(rawName); string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); @@ -414,7 +414,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (cat == ParameterCategory.Out) { - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); writer.Write($"out __{raw}"); } else if (cat == ParameterCategory.Ref) @@ -423,7 +423,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // (pointer to a value the native caller owns). On the C# delegate / interface // side it's projected as 'in T'. Read directly from * via the appropriate // marshaller — DO NOT zero or write back. - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); TypeSignature uRef = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); @@ -463,12 +463,12 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) { - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); writer.Write($"__{raw}"); } else if (cat == ParameterCategory.ReceiveArray) { - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); writer.Write($"out __{raw}"); } else @@ -491,7 +491,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); string rhs; @@ -551,7 +551,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($" ConvertToUnmanaged_{raw}(null, __{raw}, out *__{raw}Size, out *{ptr});"); } @@ -582,7 +582,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); // Determine the ABI element type for the data pointer cast. @@ -746,7 +746,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -767,7 +767,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection /// internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, ProjectionEmitContext context, ParameterInfo p) { - string rawName = p.Parameter.Name ?? "param"; + string rawName = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(rawName); if (p.Type is CorLibTypeSignature corlib && diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 9238e8ade..efc6e3a0f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -1580,7 +1580,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec /// internal static void EmitParamArgConversion(IndentedTextWriter writer, ProjectionEmitContext context, ParameterInfo p, string? paramNameOverride = null) { - string pname = paramNameOverride ?? p.Parameter.Name ?? "param"; + string pname = paramNameOverride ?? p.GetRawName(); // bool: ABI is 'bool' directly; pass as-is. if (p.Type is CorLibTypeSignature corlib && corlib.ElementType == ElementType.Boolean) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 2802226d9..26effa990 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -139,7 +139,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio { writer.WriteIf(i > 0, ", "); - string raw = sig.Parameters[i].Parameter.Name ?? "param"; + string raw = sig.Parameters[i].GetRawName(); writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); } writer.Write("))"); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 534c1b84f..22ccd9619 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -106,7 +106,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec { writer.WriteIf(i > 0, ", "); - string raw = sig.Parameters[i].Parameter.Name ?? "param"; + string raw = sig.Parameters[i].GetRawName(); writer.Write(IdentifierEscaping.EscapeIdentifier(raw)); } writer.Write("))"); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 3e30388b9..c37438d5e 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -122,7 +122,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); writer.Write(" "); @@ -155,7 +155,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); if (p.Type.IsNullableT()) @@ -191,7 +191,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); EmitMarshallerConvertToUnmanagedCallback cvt = AbiMethodBodyFactory.EmitMarshallerConvertToUnmanaged(context, p.Type, pname); writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{raw} = {cvt};"); @@ -218,7 +218,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); string abiType = AbiTypeHelpers.GetMappedAbiTypeName(p.Type); string marshaller = AbiTypeHelpers.GetMappedMarshallerName(p.Type); @@ -237,7 +237,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($" global::ABI.System.Exception __{raw} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({pname});"); } @@ -266,7 +266,7 @@ public override unsafe void Invoke( } hasNonBlittableArray = true; - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -318,7 +318,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"{baseIndent}global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({pname}, out TypeReference __{raw});"); } @@ -361,7 +361,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteIf(!firstPin, ", "); @@ -413,7 +413,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"{innerIndent}HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{raw}, {pname}?.Length, out HStringReference __{raw});"); } @@ -442,7 +442,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); if (szArr.BaseType.IsString()) @@ -493,7 +493,7 @@ public override unsafe void Invoke( { ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.Write(isMultiline: true, """ , @@ -604,7 +604,7 @@ public override unsafe void Invoke( continue; } - string raw = p.Parameter.Name ?? "param"; + string raw = p.GetRawName(); if (szArr.BaseType.IsString()) { diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index a33436310..3860c4810 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -127,7 +127,7 @@ public static WriteProjectionParameterTypeCallback WriteProjectionParameterType( /// The parameter info. public static void WriteParameterName(IndentedTextWriter writer, ParameterInfo p) { - string name = p.Parameter.Name ?? "param"; + string name = p.GetRawName(); writer.WriteIf(CSharpKeywords.IsKeyword(name), "@"); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 52da756b8..72fcd9920 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -433,7 +433,7 @@ internal static TypeSignature StripByRefAndCustomModifiers(TypeSignature sig) /// The escaped parameter name. internal static string GetParamName(ParameterInfo p, string? paramNameOverride) { - string name = paramNameOverride ?? p.Parameter.Name ?? "param"; + string name = paramNameOverride ?? p.GetRawName(); return IdentifierEscaping.EscapeIdentifier(name); } @@ -447,6 +447,6 @@ internal static string GetParamName(ParameterInfo p, string? paramNameOverride) /// The unescaped local-variable name. internal static string GetParamLocalName(ParameterInfo p, string? paramNameOverride) { - return paramNameOverride ?? p.Parameter.Name ?? "param"; + return paramNameOverride ?? p.GetRawName(); } } diff --git a/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs b/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs index abb8965bb..2bdeb654f 100644 --- a/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs +++ b/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs @@ -8,6 +8,21 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// internal static class ParameterInfoExtensions { + /// + /// Returns the parameter's raw metadata name, falling back to + /// when the metadata name is . This is the un-escaped form (no C# + /// keyword @ prefix); use it for derived identifiers such as __{rawName} + /// fixed-block locals or marshalling-state field names. For the C# keyword-escaped form, + /// use instead. + /// + /// The parameter to derive the raw name from. + /// The fallback name to use when the parameter has no metadata name. Defaults to "param". + /// The raw parameter name. + public static string GetRawName(this ParameterInfo parameter, string defaultName = "param") + { + return parameter.Parameter.Name ?? defaultName; + } + /// /// Returns the parameter's metadata name (or if the metadata /// name is ) prefixed with @ if it is a reserved C# keyword. From 9992410f06241627f1ad9cfff90ee910c88b48bc Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:30:59 -0700 Subject: [PATCH 070/171] R7-7: Unify ResolveInterfaceTypeDef into ITypeDefOrRef.ResolveAsTypeDefinition The merged R7 analysis flagged two duplicate implementations of the "resolve an interface implementation's interface reference to a TypeDefinition" helper: - `AbiTypeHelpers.ResolveInterfaceTypeDef(MetadataCache, ITypeDefOrRef)` - `InterfaceFactory.ResolveInterfaceTypeDefForExclusiveCheck(MetadataCache, ITypeDefOrRef)` Both performed the same 3-shape dispatch: 1. `TypeDefinition` -> return directly 2. `TypeReference` -> `cache.Find(ns + "." + name)` 3. `TypeSpecification` with a `GenericInstanceTypeSignature` -> recurse on the generic's open form Add `ITypeDefOrRef.ResolveAsTypeDefinition(MetadataCache)` as the canonical form (extension on `ITypeDefOrRef` so it reads naturally at call sites: `impl.Interface.ResolveAsTypeDefinition(cache)`). Implement it with the same cache-only semantics as the existing two helpers; the third (different-semantics) inline variant in MetadataAttributeFactory is intentionally left untouched here -- it uses an additional `TryResolve` cross-assembly fallback for the authoring CCW path and will be addressed separately if needed. Migrated 9 call sites: - `AbiClassFactory.cs:184, 226` - `AbiInterfaceFactory.cs:527` - `AbiInterfaceIDicFactory.cs:80, 169` - `InterfaceFactory.cs:477` - `ObjRefNameGenerator.cs:351, 379, 473` Removed both duplicate static helpers. Validation: 763/763 byte-identical across pushnot/evwithui/windows scenarios; build is 0/0 with all IDE rules. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ITypeDefOrRefExtensions.cs | 38 +++++++++++++++++++ .../Factories/AbiClassFactory.cs | 4 +- .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiInterfaceIDicFactory.cs | 4 +- .../Factories/InterfaceFactory.cs | 24 +----------- .../Helpers/AbiTypeHelpers.cs | 35 ----------------- .../Helpers/ObjRefNameGenerator.cs | 6 +-- 7 files changed, 47 insertions(+), 66 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index 2df65497b..6df3f23be 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -2,6 +2,8 @@ // Licensed under the MIT License. using AsmResolver.DotNet; +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Metadata; namespace WindowsRuntime.ProjectionWriter; @@ -36,5 +38,41 @@ internal static class ITypeDefOrRefExtensions { return type.TryResolve(context, out TypeDefinition? definition) ? definition : null; } + + /// + /// Resolves to a , handling the three + /// shapes that can appear as an interface implementation's : + /// + /// If it is already a , returns it directly. + /// If it is a whose signature is a generic instance, + /// recurses on the generic's open form (). + /// If it is a , looks it up via + /// on its qualified name. + /// + /// Returns when the type cannot be resolved. + /// + /// The metadata cache used for cross-module type-reference resolution. + /// The resolved , or on failure. + public TypeDefinition? ResolveAsTypeDefinition(MetadataCache cache) + { + if (type is TypeDefinition td) + { + return td; + } + + if (type is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + { + ITypeDefOrRef? gen = gi.GenericType; + return gen?.ResolveAsTypeDefinition(cache); + } + + if (type is TypeReference tr) + { + (string ns, string nm) = tr.Names(); + return cache.Find(string.IsNullOrEmpty(ns) ? nm : ns + "." + nm); + } + + return null; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index c66cca204..8d2c82f07 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -181,7 +181,7 @@ public static bool EmitImplType(IndentedTextWriter writer, ProjectionEmitContext continue; } - TypeDefinition? ifaceTd = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl.Interface); + TypeDefinition? ifaceTd = impl.Interface.ResolveAsTypeDefinition(context.Cache); if (ifaceTd == type && impl.IsOverridable()) { @@ -223,7 +223,7 @@ internal static void WriteClassMarshallerStub(IndentedTextWriter writer, Project // For unsealed classes, the ConvertToUnmanaged path needs to know whether the default interface is // exclusive-to. - TypeDefinition? defaultIfaceTd = defaultIface is null ? null : AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, defaultIface); + TypeDefinition? defaultIfaceTd = defaultIface?.ResolveAsTypeDefinition(context.Cache); bool defaultIfaceIsExclusive = defaultIfaceTd is not null && TypeCategorization.IsExclusiveTo(defaultIfaceTd); // Public *Marshaller class diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index c3333d2af..6f3cfd69a 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -524,7 +524,7 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj { foreach (InterfaceImplementation impl in classType.Interfaces) { - TypeDefinition? implDef = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl.Interface!); + TypeDefinition? implDef = impl.Interface!.ResolveAsTypeDefinition(context.Cache); if (implDef is not null && implDef == type) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 914e42086..ad10c5c57 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -77,7 +77,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( continue; } - TypeDefinition? required = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl.Interface); + TypeDefinition? required = impl.Interface.ResolveAsTypeDefinition(context.Cache); if (required is null) { @@ -166,7 +166,7 @@ private static void MarkAllRequiredInterfacesVisited(ProjectionEmitContext conte continue; } - TypeDefinition? r2 = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl2.Interface); + TypeDefinition? r2 = impl2.Interface.ResolveAsTypeDefinition(context.Cache); if (r2 is not null) { diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 7a2fd8817..a12f0b302 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -474,7 +474,7 @@ private static bool IsDefaultOrOverridableInterfaceTypedef(MetadataCache cache, continue; } - TypeDefinition? implDef = ResolveInterfaceTypeDefForExclusiveCheck(cache, implRef); + TypeDefinition? implDef = implRef.ResolveAsTypeDefinition(cache); if (implDef is not null && implDef == iface) { @@ -483,26 +483,4 @@ private static bool IsDefaultOrOverridableInterfaceTypedef(MetadataCache cache, } return false; } - - private static TypeDefinition? ResolveInterfaceTypeDefForExclusiveCheck(MetadataCache cache, ITypeDefOrRef ifaceRef) - { - if (ifaceRef is TypeDefinition td) - { - return td; - } - - if (ifaceRef is TypeReference tr) - { - (string ns, string nm) = tr.Names(); - return cache.Find(ns + "." + nm); - } - - if (ifaceRef is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) - { - ITypeDefOrRef? gen = gi.GenericType; - return gen is null ? null : ResolveInterfaceTypeDefForExclusiveCheck(cache, gen); - } - - return null; - } } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 72fcd9920..45687461e 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -76,41 +76,6 @@ internal static partial class AbiTypeHelpers return null; } - /// - /// Resolves an InterfaceImpl's interface reference to a TypeDefinition (same module or via metadata cache). - /// - internal static TypeDefinition? ResolveInterfaceTypeDef(MetadataCache cache, ITypeDefOrRef ifaceRef) - { - if (ifaceRef is TypeDefinition td) - { - return td; - } - - if (ifaceRef is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) - { - ITypeDefOrRef? gen = gi.GenericType; - - if (gen is TypeDefinition gtd) - { - return gtd; - } - - if (gen is TypeReference gtr) - { - (string ns, string nm) = gtr.Names(); - return cache.Find(ns + "." + nm); - } - } - - if (ifaceRef is TypeReference tr) - { - (string ns, string nm) = tr.Names(); - return cache.Find(ns + "." + nm); - } - - return null; - } - /// /// Returns the unique virtual-method name used to refer to on /// 's vtable: the method's metadata name suffixed with its zero-based diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 8bcd47812..4e5202b88 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -348,7 +348,7 @@ public static void WriteClassObjRefDefinitions(IndentedTextWriter writer, Projec if (!isDefault && ClassFactory.IsFastAbiClass(type)) { - TypeDefinition? implTypeDef = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl.Interface); + TypeDefinition? implTypeDef = impl.Interface.ResolveAsTypeDefinition(context.Cache); if (implTypeDef is not null && TypeCategorization.IsExclusiveTo(implTypeDef)) { @@ -376,7 +376,7 @@ public static void WriteClassObjRefDefinitions(IndentedTextWriter writer, Projec if (!isDefault2 && ClassFactory.IsFastAbiClass(type)) { - TypeDefinition? implTypeDef = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, impl.Interface); + TypeDefinition? implTypeDef = impl.Interface.ResolveAsTypeDefinition(context.Cache); if (implTypeDef is not null && TypeCategorization.IsExclusiveTo(implTypeDef)) { @@ -470,7 +470,7 @@ WindowsRuntimeObjectReference MakeObjectReference() private static void EmitTransitiveInterfaceObjRefs(IndentedTextWriter writer, ProjectionEmitContext context, ITypeDefOrRef ifaceRef, HashSet emitted) { // Resolve the interface to its TypeDefinition; if cross-module, look it up in the cache. - TypeDefinition? ifaceTd = AbiTypeHelpers.ResolveInterfaceTypeDef(context.Cache, ifaceRef); + TypeDefinition? ifaceTd = ifaceRef.ResolveAsTypeDefinition(context.Cache); if (ifaceTd is null) { From 47c272286d5c7381aba40d7c0916d3e64bdbfd4a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:33:09 -0700 Subject: [PATCH 071/171] R7-6: InterfaceImplementation.TryResolveTypeDef helper Add `InterfaceImplementation.TryResolveTypeDef(MetadataCache, out TypeDefinition?)` extension that combines the two-step pattern of: 1. `if (impl.Interface is null) continue;` 2. `var def = impl.Interface.ResolveAsTypeDefinition(cache); if (def is null) continue;` into a single Try- call. Marked with [NotNullWhen(true)] so callers can use the resolved definition without a follow-up null check. Migrated 4 sites that match the clean two-step pattern: - `AbiClassFactory.cs:177` (hasOverridable loop) - `AbiInterfaceFactory.cs:525` (skipExclusiveEvents probe -- also removes a latent NullReferenceException risk; the previous code used impl.Interface! without a null check) - `AbiInterfaceIDicFactory.cs:73` (DIC shim required-interface walk) - `AbiInterfaceIDicFactory.cs:162` (MarkAllRequiredInterfacesVisited) Sites NOT migrated (intentionally): - ObjRefNameGenerator fast-abi inline guards: ResolveAsTypeDefinition is nested inside a conditional branch (`if (!isDefault && IsFastAbiClass)`), not at the loop head. - ClassMembersFactory.WriteInterfaceMembers: uses a different ResolveInterface helper with its own semantics. - IidExpressionGenerator: special-cases TypeReference handling that doesn't match ResolveAsTypeDefinition's 3-shape dispatch. Validation: 763/763 byte-identical across all three scenarios; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../InterfaceImplementationExtensions.cs | 26 +++++++++++++++++++ .../Factories/AbiClassFactory.cs | 4 +-- .../Factories/AbiInterfaceFactory.cs | 4 +-- .../Factories/AbiInterfaceIDicFactory.cs | 18 ++----------- 4 files changed, 30 insertions(+), 22 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs b/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs index c5c86d665..5c89ff466 100644 --- a/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs @@ -1,7 +1,9 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System.Diagnostics.CodeAnalysis; using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Metadata; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -29,5 +31,29 @@ public bool IsDefaultInterface() /// if the interface is overridable; otherwise . public bool IsOverridable() => impl.HasAttribute(WindowsFoundationMetadata, OverridableAttribute); + + /// + /// Attempts to resolve the implemented interface to a , handling + /// the common loop-body pattern of if (impl.Interface is null) continue; followed by + /// + /// in a single call. + /// + /// The metadata cache used for cross-module type-reference resolution. + /// The resolved interface when this returns + /// ; otherwise . + /// if the interface reference resolved successfully; + /// when is or the reference + /// could not be resolved. + public bool TryResolveTypeDef(MetadataCache cache, [NotNullWhen(true)] out TypeDefinition? definition) + { + if (impl.Interface is null) + { + definition = null; + return false; + } + + definition = impl.Interface.ResolveAsTypeDefinition(cache); + return definition is not null; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 8d2c82f07..c21a8f4a9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -176,13 +176,11 @@ public static bool EmitImplType(IndentedTextWriter writer, ProjectionEmitContext bool hasOverridable = false; foreach (InterfaceImplementation impl in exclusiveToType.Interfaces) { - if (impl.Interface is null) + if (!impl.TryResolveTypeDef(context.Cache, out TypeDefinition? ifaceTd)) { continue; } - TypeDefinition? ifaceTd = impl.Interface.ResolveAsTypeDefinition(context.Cache); - if (ifaceTd == type && impl.IsOverridable()) { hasOverridable = true; diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 6f3cfd69a..087f7ef1c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -524,9 +524,7 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj { foreach (InterfaceImplementation impl in classType.Interfaces) { - TypeDefinition? implDef = impl.Interface!.ResolveAsTypeDefinition(context.Cache); - - if (implDef is not null && implDef == type) + if (impl.TryResolveTypeDef(context.Cache, out TypeDefinition? implDef) && implDef == type) { skipExclusiveEvents = true; break; diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index ad10c5c57..cd644fe34 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -72,14 +72,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( { foreach (InterfaceImplementation impl in type.Interfaces) { - if (impl.Interface is null) - { - continue; - } - - TypeDefinition? required = impl.Interface.ResolveAsTypeDefinition(context.Cache); - - if (required is null) + if (!impl.TryResolveTypeDef(context.Cache, out TypeDefinition? required)) { continue; } @@ -161,14 +154,7 @@ private static void MarkAllRequiredInterfacesVisited(ProjectionEmitContext conte { foreach (InterfaceImplementation impl2 in required.Interfaces) { - if (impl2.Interface is null) - { - continue; - } - - TypeDefinition? r2 = impl2.Interface.ResolveAsTypeDefinition(context.Cache); - - if (r2 is not null) + if (impl2.TryResolveTypeDef(context.Cache, out TypeDefinition? r2)) { _ = visited.Add(r2); } From 79fa44b4b0778a3f644ee09bf0c80cca5f9be2ab Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:34:42 -0700 Subject: [PATCH 072/171] R7-8: TypeDefinition.GetNonSpecialMethods iterator Add `TypeDefinition.GetNonSpecialMethods()` extension that yields the type's methods excluding special-name ones (property accessors, event accessors, .ctor, etc.), filtering via the existing `MethodDefinition.IsSpecial` predicate. The exact loop pattern repeated in 8 sites: foreach (MethodDefinition method in type.Methods) { if (method.IsSpecial()) continue; // ... } becomes: foreach (MethodDefinition method in type.GetNonSpecialMethods()) { // ... } Migrated 6 of the 8 sites: - `AbiInterfaceIDicFactory.cs:263, 387` (DIC shim / static-ABI emission) - `AbiMethodBodyFactory.MethodsClass.cs:52` (Methods class virtual stubs) - `ClassFactory.cs:348` (static interface methods) - `ClassMembersFactory.WriteInterfaceMembers.cs:254` (interface members on class) - `InterfaceFactory.cs:239` (interface member signatures) Sites NOT migrated: - `ConstructorFactory.AttributedTypes.cs:111` and `ConstructorFactory.Composable.cs:51` -- both have `methodIndex++; continue;` in the IsSpecial branch, so they need to count special methods too. An iterator that skips them would break the slot-index tracking. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeDefinitionExtensions.cs | 17 +++++++++++++++++ .../Factories/AbiInterfaceIDicFactory.cs | 14 ++------------ .../AbiMethodBodyFactory.MethodsClass.cs | 7 +------ .../Factories/ClassFactory.cs | 7 +------ ...ClassMembersFactory.WriteInterfaceMembers.cs | 7 +------ .../Factories/InterfaceFactory.cs | 7 +------ 6 files changed, 23 insertions(+), 36 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 11b679339..10b571357 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System.Collections.Generic; using AsmResolver.DotNet; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -14,6 +15,22 @@ internal static class TypeDefinitionExtensions { extension(TypeDefinition type) { + /// + /// Returns the type's methods filtered to exclude special-name methods (property accessors, + /// event accessors, and runtime-special methods like .ctor). + /// + /// The non-special methods in declaration order. + public IEnumerable GetNonSpecialMethods() + { + foreach (MethodDefinition method in type.Methods) + { + if (!method.IsSpecial()) + { + yield return method; + } + } + } + /// /// Returns the [Default] interface of the type (the interface whose vtable backs the /// type's IInspectable identity), or if the type does not declare one. diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index cd644fe34..d8791ca9c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -260,13 +260,8 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented // delegating thunks we cast through this same projected interface type. string ccwIfaceName = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.Projected, true).Format(); - foreach (MethodDefinition method in type.Methods) + foreach (MethodDefinition method in type.GetNonSpecialMethods()) { - if (method.IsSpecial()) - { - continue; - } - MethodSignatureInfo sig = new(method); string mname = method.Name?.Value ?? string.Empty; @@ -384,13 +379,8 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite // The static ABI Methods class name. string abiClass = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.StaticAbiClass, true).Format(); - foreach (MethodDefinition method in type.Methods) + foreach (MethodDefinition method in type.GetNonSpecialMethods()) { - if (method.IsSpecial()) - { - continue; - } - MethodSignatureInfo sig = new(method); string mname = method.Name?.Value ?? string.Empty; diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 80d69cee1..93f75a310 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -49,13 +49,8 @@ internal static void EmitMethodsClassMembersFor(IndentedTextWriter writer, Proje } // Emit non-special methods first (output order is unchanged from before; only the slot lookup changes). - foreach (MethodDefinition method in type.Methods) + foreach (MethodDefinition method in type.GetNonSpecialMethods()) { - if (method.IsSpecial()) - { - continue; - } - string mname = method.Name?.Value ?? string.Empty; MethodSignatureInfo sig = new(method); diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 4c430a4ee..15142cae6 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -345,13 +345,8 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, staticIface); // Methods - foreach (MethodDefinition method in staticIface.Methods) + foreach (MethodDefinition method in staticIface.GetNonSpecialMethods()) { - if (method.IsSpecial()) - { - continue; - } - MethodSignatureInfo sig = new(method); string mname = method.Name?.Value ?? string.Empty; writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 0fe70f55b..37d6d8fdf 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -251,13 +251,8 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, ifaceType); // Methods - foreach (MethodDefinition method in ifaceType.Methods) + foreach (MethodDefinition method in ifaceType.GetNonSpecialMethods()) { - if (method.IsSpecial()) - { - continue; - } - string name = method.Name?.Value ?? string.Empty; // Track by full signature (name + each param's element-type code) to avoid trivial overload duplicates. // This prevents collapsing distinct overloads like Format(double) and Format(ulong). diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index a12f0b302..f735fc368 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -236,13 +236,8 @@ public static string WritePropType(ProjectionEmitContext context, PropertyDefini /// public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - foreach (MethodDefinition method in type.Methods) + foreach (MethodDefinition method in type.GetNonSpecialMethods()) { - if (method.IsSpecial()) - { - continue; - } - MethodSignatureInfo sig = new(method); // Only emit Windows.Foundation.Metadata attributes that have a projected form // (Overload, DefaultOverload, AttributeUsage, Experimental). From ddb4504aeb357c10d1cb5c6b0a0ed905a86ee49a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:35:55 -0700 Subject: [PATCH 073/171] R7-9: InteropTypeNameWriter.GetInteropAssemblyQualifiedName helper Add `GetInteropAssemblyQualifiedName(sig, nameType=ABI)` which wraps `EncodeInteropTypeName(sig, nameType) + ", WinRT.Interop"` -- the form that is canonical for `[UnsafeAccessorType]` attribute values. Removes the magic-string ", WinRT.Interop" from 11 call sites: - `AbiMethodBodyFactory.DoAbi.cs:70, 100, 356` - `AbiMethodBodyFactory.MethodsClass.cs:151` - `AbiMethodBodyFactory.RcwCaller.cs:284, 1100, 1234` - `ClassMembersFactory.WriteInterfaceMembers.cs:243, 455` - `ConstructorFactory.FactoryCallbacks.cs:169` - `EventTableFactory.cs:80` Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 6 +++--- .../Factories/AbiMethodBodyFactory.MethodsClass.cs | 2 +- .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 6 +++--- .../ClassMembersFactory.WriteInterfaceMembers.cs | 4 ++-- .../ConstructorFactory.FactoryCallbacks.cs | 2 +- .../Factories/EventTableFactory.cs | 2 +- .../Helpers/InteropTypeNameWriter.cs | 13 +++++++++++++ 7 files changed, 24 insertions(+), 11 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 3117ee9af..9cd4910f4 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -67,7 +67,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // instead of the generic-instance UnsafeAccessor (V3-M7). if (returnIsGenericInstance && !(rt is not null && rt.IsNullableT())) { - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(rt!, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(rt!, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt!, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] @@ -97,7 +97,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.GetRawName(); - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(uOut, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] @@ -353,7 +353,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { string rawName = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(rawName); - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 93f75a310..3ab319481 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -148,7 +148,7 @@ public static unsafe } string eventSourceInteropType = isGenericEvent - ? InteropTypeNameWriter.EncodeInteropTypeName(evtSig, TypedefNameType.EventSource) + ", WinRT.Interop" + ? InteropTypeNameWriter.GetInteropAssemblyQualifiedName(evtSig, TypedefNameType.EventSource) : string.Empty; // Emit the per-event ConditionalWeakTable static field. diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index efc6e3a0f..bf5a2c8b7 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -281,7 +281,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Generic instance param: emit a local UnsafeAccessor delegate to get the marshaller method. string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] @@ -1097,7 +1097,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // emits the accessor inside try, right before the assignment). if (uOut.IsGenericInstance()) { - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(uOut, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(uOut, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] @@ -1231,7 +1231,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (rt.IsGenericInstance()) { - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(rt, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(rt, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 37d6d8fdf..7e39a3eb1 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -240,7 +240,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE { string projectedParent = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(currentInstance), TypedefNameType.Projected, true).Format(); genericParentEncoded = IidExpressionGenerator.EscapeTypeNameForIdentifier(projectedParent, stripGlobal: true); - genericInteropType = InteropTypeNameWriter.EncodeInteropTypeName(currentInstance, TypedefNameType.StaticAbiClass) + ", WinRT.Interop"; + genericInteropType = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(currentInstance, TypedefNameType.StaticAbiClass); } // Compute the platform attribute string from the interface type's [ContractVersion] @@ -452,7 +452,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // The "interop" type name string for the EventSource UnsafeAccessor (only needed for generic events). string eventSourceInteropType = isGenericEvent - ? InteropTypeNameWriter.EncodeInteropTypeName(evtSig, TypedefNameType.EventSource) + ", WinRT.Interop" + ? InteropTypeNameWriter.GetInteropAssemblyQualifiedName(evtSig, TypedefNameType.EventSource) : string.Empty; // Compute vtable index = method index in the interface vtable + 6 (for IInspectable methods). diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index c37438d5e..9ba2a6eb5 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -166,7 +166,7 @@ public override unsafe void Invoke( continue; } - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(p.Type, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index a8c999d74..6f9457084 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -77,7 +77,7 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit if (isGeneric) { - string interopTypeName = InteropTypeNameWriter.EncodeInteropTypeName(evtTypeSig, TypedefNameType.ABI) + ", WinRT.Interop"; + string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(evtTypeSig, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, evtTypeSig, false); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] diff --git a/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs index 8e9d4dceb..f87940611 100644 --- a/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs @@ -33,6 +33,19 @@ public static string EncodeInteropTypeName(TypeSignature sig, TypedefNameType na return sb.ToString(); } + /// + /// Returns the assembly-qualified form of , + /// suffixed with ", WinRT.Interop". This is the canonical value passed to + /// [UnsafeAccessorType] arguments. + /// + /// The type signature to encode. + /// Indicates whether to use the projected (no ABI prefix) form or + /// the ABI-prefixed marshaller form. Defaults to . + public static string GetInteropAssemblyQualifiedName(TypeSignature sig, TypedefNameType nameType = TypedefNameType.ABI) + { + return EncodeInteropTypeName(sig, nameType) + ", WinRT.Interop"; + } + /// /// Encodes an ABI interop type name for into using the format expected by WindowsRuntime.InteropServices attributes. /// From 660522c589bf089f0525bae1e334641cbd0343bf Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:37:32 -0700 Subject: [PATCH 074/171] R7-10, R7-24: MappedTypes.ApplyMapping and IsMapped helpers Add two helpers to `MappedTypes`: - `ApplyMapping(ref string ns, ref string name)`: mutates ns/name in-place when a mapping exists, returns whether one was applied. - `IsMapped(string ns, string name)`: boolean-only convenience for the `MappedTypes.Get(ns, name) is not null` pattern. Collapses the repeated 5-line block: MappedType? mapped = MappedTypes.Get(ns, name); if (mapped is { } m) { ns = m.MappedNamespace; name = m.MappedName; } into a single `_ = MappedTypes.ApplyMapping(ref ns, ref name);` call. Migrated 15 blocks across 6 files: - `AbiTypeHelpers.AbiTypeNames.cs:93, 149` (2) - `AbiTypeHelpers.Marshallers.cs:127` (1) - `ObjRefNameGenerator.cs:35, 48, 79, 99, 120` (5) - `ClassMembersFactory.cs:143, 157` (2) - `InterfaceFactory.cs:70, 161, 182` (3) - `TypedefNameWriter.cs:217, 262` (2) Plus 2 `IsMapped` calls in `ObjRefNameGenerator.cs:156, 162`. Note: kept the `ApplyMapping` shape (vs. the report's `ITypeDefOrRef.NamesAfterMapping()`) because most sites already have ns/name locals derived from sources other than a direct `.Names()` call. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ClassMembersFactory.cs | 16 +------ .../Factories/InterfaceFactory.cs | 24 ++-------- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 16 +------ .../Helpers/AbiTypeHelpers.Marshallers.cs | 8 +--- .../Helpers/MappedTypes.cs | 30 +++++++++++++ .../Helpers/ObjRefNameGenerator.cs | 44 +++---------------- .../Helpers/TypedefNameWriter.cs | 16 +------ 7 files changed, 47 insertions(+), 107 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index d657115be..a447c38cf 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -140,13 +140,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro else if (ifaceType is TypeReference tr) { (string ns, string name) = tr.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); writer.Write($"global::{ns}.{IdentifierEscaping.StripBackticks(name)}"); } @@ -154,13 +148,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro { ITypeDefOrRef gt = gi.GenericType; (string ns, string name) = gt.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); writer.Write($"global::{ns}.{IdentifierEscaping.StripBackticks(name)}<"); for (int i = 0; i < gi.TypeArguments.Count; i++) diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index f735fc368..f376c0181 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -67,13 +67,7 @@ public static void WriteTypeInheritance(IndentedTextWriter writer, ProjectionEmi // only emit 'global::' when the base class lives in a different namespace. ITypeDefOrRef baseType = type.BaseType!; (string ns, string name) = baseType.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); if (!string.IsNullOrEmpty(ns) && ns != context.CurrentNamespace) { @@ -158,13 +152,7 @@ public static void WriteInterfaceTypeName(IndentedTextWriter writer, ProjectionE else if (ifaceType is TypeReference tr) { (string ns, string name) = tr.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m1) - { - ns = m1.MappedNamespace; - name = m1.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); // Only emit the global:: prefix when the namespace doesn't match the current emit // namespace (mirrors WriteTypedefName behavior -- same-namespace stays unqualified). @@ -179,13 +167,7 @@ public static void WriteInterfaceTypeName(IndentedTextWriter writer, ProjectionE { ITypeDefOrRef gt = gi.GenericType; (string ns, string name) = gt.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m2) - { - ns = m2.MappedNamespace; - name = m2.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); if (!string.IsNullOrEmpty(ns) && ns != context.CurrentNamespace) { diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 7d3a3c055..66b35c498 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -90,13 +90,7 @@ internal static string GetAbiStructTypeName(IndentedTextWriter writer, Projectio // If this struct is mapped, use the mapped namespace+name (e.g. // 'Windows.UI.Xaml.Interop.TypeName' is mapped to 'System.Type', so the ABI struct // is 'global::ABI.System.Type', not 'global::ABI.Windows.UI.Xaml.Interop.TypeName'). - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); return GlobalAbiPrefix + ns + "." + IdentifierEscaping.StripBackticks(name); } @@ -146,13 +140,7 @@ private static string GetProjectedEnumName(TypeDefinition def) // (e.g. Windows.UI.Xaml.Interop.NotifyCollectionChangedAction → // System.Collections.Specialized.NotifyCollectionChangedAction). Same // remapping that WriteTypedefName performs. - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); return string.IsNullOrEmpty(ns) ? GlobalPrefix + name : GlobalPrefix + ns + "." + name; } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs index d7ba1543f..ff3dcaf89 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs @@ -124,13 +124,7 @@ internal static string GetMarshallerFullName(IndentedTextWriter writer, Projecti string ns = td.Type?.Namespace?.Value ?? string.Empty; string name = td.Type?.Name?.Value ?? string.Empty; // Apply mapped type remapping (e.g. System.Uri -> Windows.Foundation.Uri) - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); return GlobalAbiPrefix + ns + "." + IdentifierEscaping.StripBackticks(name) + MarshallerSuffix; } diff --git a/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs b/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs index a473fff02..96f1b9e84 100644 --- a/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs @@ -59,6 +59,36 @@ internal static class MappedTypes /// if there is at least one mapping in this namespace. public static bool HasNamespace(string typeNamespace) => TypeMappings.ContainsKey(typeNamespace); + /// + /// Returns whether a mapping exists for the type identified by + /// (, ). + /// + /// The Windows Runtime namespace. + /// The Windows Runtime type name. + /// if a mapping exists; otherwise . + public static bool IsMapped(string typeNamespace, string typeName) + => Get(typeNamespace, typeName) is not null; + + /// + /// Applies the type mapping in-place if one exists: when a mapping is found for the type + /// identified by (, ), replaces + /// both fields with the mapped namespace and name. Does nothing if no mapping exists. + /// + /// The Windows Runtime namespace; replaced with the mapped namespace on a hit. + /// The Windows Runtime type name; replaced with the mapped name on a hit. + /// if a mapping was applied; otherwise . + public static bool ApplyMapping(ref string typeNamespace, ref string typeName) + { + if (Get(typeNamespace, typeName) is { } m) + { + typeNamespace = m.MappedNamespace; + typeName = m.MappedName; + return true; + } + + return false; + } + private static FrozenDictionary> Build() { Dictionary> result = []; diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 4e5202b88..0e3295a22 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -32,26 +32,14 @@ public static string GetObjRefName(ProjectionEmitContext context, ITypeDefOrRef if (ifaceType is TypeDefinition td) { (string ns, string name) = td.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); projected = GlobalPrefix + ns + "." + IdentifierEscaping.StripBackticks(name); } else if (ifaceType is TypeReference tr) { (string ns, string name) = tr.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); projected = GlobalPrefix + ns + "." + IdentifierEscaping.StripBackticks(name); } @@ -76,13 +64,7 @@ private static void WriteFullyQualifiedInterfaceName(IndentedTextWriter writer, if (ifaceType is TypeDefinition td) { (string ns, string name) = td.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); writer.Write(GlobalPrefix); @@ -96,13 +78,7 @@ private static void WriteFullyQualifiedInterfaceName(IndentedTextWriter writer, else if (ifaceType is TypeReference tr) { (string ns, string name) = tr.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); writer.Write(GlobalPrefix); @@ -117,13 +93,7 @@ private static void WriteFullyQualifiedInterfaceName(IndentedTextWriter writer, { ITypeDefOrRef gt = gi.GenericType; (string ns, string name) = gt.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); writer.Write(GlobalPrefix); @@ -183,13 +153,13 @@ public static void WriteIidExpression(IndentedTextWriter writer, ProjectionEmitC { ns = td.Namespace?.Value ?? string.Empty; name = td.Name?.Value ?? string.Empty; - isMapped = MappedTypes.Get(ns, name) is not null; + isMapped = MappedTypes.IsMapped(ns, name); } else if (ifaceType is TypeReference tr) { ns = tr.Namespace?.Value ?? string.Empty; name = tr.Name?.Value ?? string.Empty; - isMapped = MappedTypes.Get(ns, name) is not null; + isMapped = MappedTypes.IsMapped(ns, name); } else { diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 7c62cfee5..aca3c1e3c 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -214,13 +214,7 @@ public static void WriteTypeName(IndentedTextWriter writer, ProjectionEmitContex case TypeSemantics.GenericInstanceRef gir: { (string ns, string name) = gir.GenericType.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); if (nameType == TypedefNameType.EventSource && ns == "System") { @@ -259,13 +253,7 @@ public static void WriteTypeName(IndentedTextWriter writer, ProjectionEmitContex case TypeSemantics.Reference r: { (string ns, string name) = r.Type.Names(); - MappedType? mapped = MappedTypes.Get(ns, name); - - if (mapped is { } m) - { - ns = m.MappedNamespace; - name = m.MappedName; - } + _ = MappedTypes.ApplyMapping(ref ns, ref name); bool needsNsPrefix = !string.IsNullOrEmpty(ns) && ( forceWriteNamespace || From ebdfcc5b7c368bb832d4a9da474ee43bfc1d4b03 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:38:53 -0700 Subject: [PATCH 075/171] R7-11: MetadataCache.Find(ns, name) and Find(ITypeDefOrRef) overloads Add two overloads on `MetadataCache.Find` that centralise the `ns + "." + name` concat (and the empty-namespace special case `string.IsNullOrEmpty(ns) ? name : ns + "." + name`) at one place: - `Find(string ns, string name)` - `Find(ITypeDefOrRef type)` -- convenience that extracts both via Names() Migrated 13 call sites: - `AbiTypeHelpers.AbiTypeNames.cs:124` - `AbiTypeHelpers.Blittability.cs:108, 138, 162, 198, 253, 290, 363` (8) - `AbiTypeHelpers.cs:343` (was using the empty-ns special-case form) - `ITypeDefOrRefExtensions.cs:72` (the canonical ResolveAsTypeDefinition impl added in R7-7 -- now reads cleaner) - `IidExpressionGenerator.cs:258, 290, 492` - `AbiTypeWriter.cs:124, 130` Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ITypeDefOrRefExtensions.cs | 2 +- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 +- .../Helpers/AbiTypeHelpers.Blittability.cs | 14 ++++++------- .../Helpers/AbiTypeHelpers.cs | 2 +- .../Helpers/AbiTypeWriter.cs | 4 ++-- .../Helpers/IidExpressionGenerator.cs | 6 +++--- .../Metadata/MetadataCache.cs | 20 ++++++++++++++++++- 7 files changed, 34 insertions(+), 16 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index 6df3f23be..fc80768fc 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -69,7 +69,7 @@ internal static class ITypeDefOrRefExtensions if (type is TypeReference tr) { (string ns, string nm) = tr.Names(); - return cache.Find(string.IsNullOrEmpty(ns) ? nm : ns + "." + nm); + return cache.Find(ns, nm); } return null; diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 66b35c498..d848f8144 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -121,7 +121,7 @@ internal static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature si if (def is null && td.Type is TypeReference tr) { (string ns, string name) = tr.Names(); - def = cache.Find(ns + "." + name); + def = cache.Find(ns, name); } if (def is not null && TypeCategorization.GetCategory(def) == TypeCategory.Enum) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 636f9a47b..ffa0e59fd 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -105,7 +105,7 @@ internal static bool IsFieldTypeBlittable(MetadataCache cache, TypeSignature sig if (todr.Type is TypeReference tr) { (string ns, string name) = tr.Names(); - TypeDefinition? resolved = cache.Find(ns + "." + name); + TypeDefinition? resolved = cache.Find(ns, name); if (resolved is not null) { @@ -135,7 +135,7 @@ internal static bool IsFieldTypeBlittable(MetadataCache cache, TypeSignature sig if (tdr.Type is TypeReference tr) { (string ns, string name) = tr.Names(); - return cache.Find(ns + "." + name); + return cache.Find(ns, name); } return null; @@ -159,7 +159,7 @@ internal static bool IsEnumType(MetadataCache cache, TypeSignature sig) if (td.Type is TypeReference tr) { (string ns, string name) = tr.Names(); - TypeDefinition? resolved = cache.Find(ns + "." + name); + TypeDefinition? resolved = cache.Find(ns, name); return resolved is not null && TypeCategorization.GetCategory(resolved) == TypeCategory.Enum; } @@ -195,7 +195,7 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur if (cache is not null) { - TypeDefinition? resolved = cache.Find(ns + "." + name); + TypeDefinition? resolved = cache.Find(ns, name); if (resolved is not null) { @@ -250,7 +250,7 @@ ElementType.R8 or if (td.Type is TypeReference tr) { (string ns, string name) = tr.Names(); - TypeDefinition? resolved = cache.Find(ns + "." + name); + TypeDefinition? resolved = cache.Find(ns, name); if (resolved is not null && TypeCategorization.GetCategory(resolved) == TypeCategory.Enum) { @@ -287,7 +287,7 @@ internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) return false; } - def = cache.Find(ns + "." + name); + def = cache.Find(ns, name); } if (def is null) @@ -360,7 +360,7 @@ internal static bool IsAnyStruct(MetadataCache cache, TypeSignature sig) return true; } - def = cache.Find(ns + "." + name); + def = cache.Find(ns, name); } if (def is null) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 45687461e..5d2895df1 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -340,7 +340,7 @@ internal static int GetClassHierarchyIndex(MetadataCache cache, TypeDefinition c if (baseDef is null) { baseDef = classType.BaseType.TryResolve(cache.RuntimeContext); - baseDef ??= cache.Find(string.IsNullOrEmpty(ns) ? nm : (ns + "." + nm)); + baseDef ??= cache.Find(ns, nm); } if (baseDef is null) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 700b81d03..865d8242b 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -121,13 +121,13 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext } // Look up the type by its ORIGINAL (unmapped) name in the cache. - TypeDefinition? rd = context.Cache.Find(rns + "." + rname); + TypeDefinition? rd = context.Cache.Find(rns, rname); // If not found, try the mapped name (for cases where the mapping target is in the cache). if (rd is null) { if (MappedTypes.Get(rns, rname) is { } rmapped) { - rd = context.Cache.Find(rmapped.MappedNamespace + "." + rmapped.MappedName); + rd = context.Cache.Find(rmapped.MappedNamespace, rmapped.MappedName); } } diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 26e2f651f..d2118732f 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -255,7 +255,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC if (context.Cache is not null) { resolved = r.Type.TryResolve(context.Cache.RuntimeContext) - ?? context.Cache.Find(string.IsNullOrEmpty(ns) ? name : (ns + "." + name)); + ?? context.Cache.Find(ns, name); } if (resolved is not null) @@ -287,7 +287,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC if (context.Cache is not null) { resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) - ?? context.Cache.Find(string.IsNullOrEmpty(ns) ? name : (ns + "." + name)); + ?? context.Cache.Find(ns, name); } if (resolved is not null) @@ -489,7 +489,7 @@ public static void WriteIidGuidPropertyForClassInterfaces(IndentedTextWriter wri } private static TypeDefinition? ResolveCrossModuleType(MetadataCache cache, string ns, string name) { - return cache.Find(string.IsNullOrEmpty(ns) ? name : (ns + "." + name)); + return cache.Find(ns, name); } /// diff --git a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs index 95769f073..c0dfb2ad2 100644 --- a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs +++ b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs @@ -18,7 +18,7 @@ internal sealed class MetadataCache /// Backing field for . private readonly Dictionary _namespaces = []; - /// Backing field for the global type-by-full-name index used by . + /// Backing field for the global type-by-full-name index used by . private readonly Dictionary _typesByFullName = []; /// Backing field for the type-to-source-module-path index used by . @@ -210,6 +210,24 @@ public string GetSourcePath(TypeDefinition type) return _typesByFullName.TryGetValue(fullName, out TypeDefinition? type) ? type : null; } + /// + /// Looks up a type by its namespace and name; the namespace can be empty for global types. + /// Centralises the empty-namespace handling that is otherwise open-coded inconsistently. + /// + public TypeDefinition? Find(string typeNamespace, string typeName) + { + return Find(string.IsNullOrEmpty(typeNamespace) ? typeName : typeNamespace + "." + typeName); + } + + /// + /// Looks up a type by its namespace and name extracted from . + /// + public TypeDefinition? Find(ITypeDefOrRef type) + { + (string ns, string name) = type.Names(); + return Find(ns, name); + } + /// /// Gets a type by full name, throwing if not found. /// From db13c14f9c49561547992ab49586b7cea5e30eb4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:41:33 -0700 Subject: [PATCH 076/171] R7-14, R7-28: MethodDefinition accessor-kind + WindowsFoundationMetadata predicates **R7-14**: Add IsGetter/IsSetter/IsAdder/IsRemover predicates on `MethodDefinition`, mirroring the existing `IsRemoveOverload` shape (each requires `IsSpecialName` plus a `StartsWith` check on the `get_` / `put_` / `add_` / `remove_` prefix). Migrated the 4 inline booleans at `AbiMethodBodyFactory.DoAbi.cs:39-42` to use `sig.Method.IsGetter()` etc. **R7-28**: Add `HasWindowsFoundationMetadataAttribute(name)` and `GetWindowsFoundationMetadataAttribute(name)` convenience methods on the existing `IHasCustomAttribute` extension block. Used the full name as requested (no `Wfm` abbreviation). Migrated 14 sites across 9 files: - `Extensions\InterfaceImplementationExtensions.cs` (2) - `Extensions\MethodDefinitionExtensions.cs` (1) - `Extensions\PropertyDefinitionExtensions.cs` (1) - `Extensions\TypeDefinitionExtensions.cs` (2) - `Factories\ClassFactory.cs` (2) - `Factories\ClassMembersFactory.WriteInterfaceMembers.cs` (1) - `Generation\ProjectionGenerator.Component.cs` (2) - `Helpers\IidExpressionGenerator.cs` (1) - `Helpers\ObjRefNameGenerator.cs` (2) Also dropped 8 now-unused `using static ... WellKnownNamespaces;` directives. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../IHasCustomAttributeExtensions.cs | 16 ++++++++++ .../InterfaceImplementationExtensions.cs | 5 ++-- .../Extensions/MethodDefinitionExtensions.cs | 30 +++++++++++++++++-- .../PropertyDefinitionExtensions.cs | 3 +- .../Extensions/TypeDefinitionExtensions.cs | 5 ++-- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 9 +++--- .../Factories/ClassFactory.cs | 4 +-- ...assMembersFactory.WriteInterfaceMembers.cs | 3 +- .../ProjectionGenerator.Component.cs | 5 ++-- .../Helpers/IidExpressionGenerator.cs | 3 +- .../Helpers/ObjRefNameGenerator.cs | 5 ++-- 11 files changed, 61 insertions(+), 27 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs b/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs index 5f85f0569..0c4f95371 100644 --- a/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs @@ -53,5 +53,21 @@ public bool HasAttribute(string ns, string name) } return null; } + + /// + /// Convenience for HasAttribute(ns, name) with the namespace fixed to + /// Windows.Foundation.Metadata. + /// + /// The unqualified name of the Windows.Foundation.Metadata attribute. + public bool HasWindowsFoundationMetadataAttribute(string name) + => member.HasAttribute(References.WellKnownNamespaces.WindowsFoundationMetadata, name); + + /// + /// Convenience for GetAttribute(ns, name) with the namespace fixed to + /// Windows.Foundation.Metadata. + /// + /// The unqualified name of the Windows.Foundation.Metadata attribute. + public CustomAttribute? GetWindowsFoundationMetadataAttribute(string name) + => member.GetAttribute(References.WellKnownNamespaces.WindowsFoundationMetadata, name); } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs b/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs index 5c89ff466..efb57e750 100644 --- a/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs @@ -5,7 +5,6 @@ using AsmResolver.DotNet; using WindowsRuntime.ProjectionWriter.Metadata; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter; @@ -22,7 +21,7 @@ internal static class InterfaceImplementationExtensions /// /// if the interface is the default interface; otherwise . public bool IsDefaultInterface() - => impl.HasAttribute(WindowsFoundationMetadata, DefaultAttribute); + => impl.HasWindowsFoundationMetadataAttribute(DefaultAttribute); /// /// Returns whether the implemented interface is marked [Overridable] (i.e. derived @@ -30,7 +29,7 @@ public bool IsDefaultInterface() /// /// if the interface is overridable; otherwise . public bool IsOverridable() - => impl.HasAttribute(WindowsFoundationMetadata, OverridableAttribute); + => impl.HasWindowsFoundationMetadataAttribute(OverridableAttribute); /// /// Attempts to resolve the implemented interface to a , handling diff --git a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs index 2c093bd1b..e4de40bfd 100644 --- a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs @@ -4,7 +4,6 @@ using System; using AsmResolver.DotNet; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter; @@ -39,12 +38,39 @@ public bool IsSpecial() public bool IsRemoveOverload() => method.IsSpecialName && (method.Name?.Value?.StartsWith("remove_", StringComparison.Ordinal) == true); + /// + /// Returns whether the method is a property getter (special method whose name starts with get_). + /// + /// if the method is a property getter; otherwise . + public bool IsGetter() + => method.IsSpecialName && (method.Name?.Value?.StartsWith("get_", StringComparison.Ordinal) == true); + + /// + /// Returns whether the method is a property setter (special method whose name starts with put_). + /// + /// if the method is a property setter; otherwise . + public bool IsSetter() + => method.IsSpecialName && (method.Name?.Value?.StartsWith("put_", StringComparison.Ordinal) == true); + + /// + /// Returns whether the method is an event adder (special method whose name starts with add_). + /// + /// if the method is an event adder; otherwise . + public bool IsAdder() + => method.IsSpecialName && (method.Name?.Value?.StartsWith("add_", StringComparison.Ordinal) == true); + + /// + /// Returns whether the method is an event remover (alias for ). + /// + /// if the method is an event remover; otherwise . + public bool IsRemover() => method.IsRemoveOverload(); + /// /// Returns whether the method carries the [NoExceptionAttribute] or is a /// (event removers are implicitly no-throw). /// /// if the method is documented to never throw; otherwise . public bool IsNoExcept() - => method.IsRemoveOverload() || method.HasAttribute(WindowsFoundationMetadata, NoExceptionAttribute); + => method.IsRemoveOverload() || method.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); } } diff --git a/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs index 83daa0b3b..c3ea900ec 100644 --- a/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs @@ -3,7 +3,6 @@ using AsmResolver.DotNet; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter; @@ -19,7 +18,7 @@ internal static class PropertyDefinitionExtensions /// /// if the property is documented to never throw; otherwise . public bool IsNoExcept() - => property.HasAttribute(WindowsFoundationMetadata, NoExceptionAttribute); + => property.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); /// /// Returns the (getter, setter) accessor pair of the property. diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 10b571357..309c9f166 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -4,7 +4,6 @@ using System.Collections.Generic; using AsmResolver.DotNet; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter; @@ -89,7 +88,7 @@ public bool HasDefaultConstructor() /// The contract version, or . public int? GetContractVersion() { - CustomAttribute? attr = type.GetAttribute(WindowsFoundationMetadata, ContractVersionAttribute); + CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute(ContractVersionAttribute); if (attr is null) { @@ -122,7 +121,7 @@ public bool HasDefaultConstructor() /// The version, or . public int? GetVersion() { - CustomAttribute? attr = type.GetAttribute(WindowsFoundationMetadata, VersionAttribute); + CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute(VersionAttribute); if (attr is null) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 9cd4910f4..ab56553df 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -1,7 +1,6 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using System; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Errors; @@ -36,10 +35,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection bool returnIsGenericInstance = rt is not null && rt.IsGenericInstance(); bool returnIsBlittableStruct = rt is not null && context.AbiTypeShapeResolver.IsBlittableStruct(rt); - bool isGetter = methodName.StartsWith("get_", StringComparison.Ordinal); - bool isSetter = methodName.StartsWith("put_", StringComparison.Ordinal); - bool isAddEvent = methodName.StartsWith("add_", StringComparison.Ordinal); - bool isRemoveEvent = methodName.StartsWith("remove_", StringComparison.Ordinal); + bool isGetter = sig.Method.IsGetter(); + bool isSetter = sig.Method.IsSetter(); + bool isAddEvent = sig.Method.IsAdder(); + bool isRemoveEvent = sig.Method.IsRemover(); if (isAddEvent || isRemoveEvent) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 15142cae6..a4c67c422 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -33,7 +33,7 @@ public static bool IsFastAbiClass(TypeDefinition type) { // Fast ABI is enabled when the type is marked [FastAbi]. (CsWinRT 3.0 has no // netstandard_compat gate -- it was always false in the C# port.) - return type.HasAttribute(WindowsFoundationMetadata, FastAbiAttribute); + return type.HasWindowsFoundationMetadataAttribute(FastAbiAttribute); } /// @@ -249,7 +249,7 @@ public static int GetGcPressureAmount(TypeDefinition type) return 0; } - CustomAttribute? attr = type.GetAttribute(WindowsFoundationMetadata, "GCPressureAttribute"); + CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute("GCPressureAttribute"); if (attr is null || attr.Signature is null) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 7e39a3eb1..398296aff 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -15,7 +15,6 @@ using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -50,7 +49,7 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr _ = writtenInterfaces.Add(ifaceType); bool isOverridable = impl.IsOverridable(); - bool isProtected = impl.HasAttribute(WindowsFoundationMetadata, "ProtectedAttribute"); + bool isProtected = impl.HasWindowsFoundationMetadataAttribute("ProtectedAttribute"); // Substitute generic type arguments using the current generic context BEFORE emitting // any references to this interface. This is critical for nested recursion: e.g. when diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs index 5c66a0f54..98a55ed29 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs @@ -8,7 +8,6 @@ using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Generation; @@ -46,8 +45,8 @@ internal sealed partial class ProjectionGenerator continue; } - if (type.HasAttribute(WindowsFoundationMetadata, ActivatableAttribute) || - type.HasAttribute(WindowsFoundationMetadata, StaticAttribute)) + if (type.HasWindowsFoundationMetadataAttribute(ActivatableAttribute) || + type.HasWindowsFoundationMetadataAttribute(StaticAttribute)) { _ = componentActivatable.Add(type); string moduleName = Path.GetFileNameWithoutExtension(_cache.GetSourcePath(type)); diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index d2118732f..5e218a1db 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -13,7 +13,6 @@ using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -73,7 +72,7 @@ public static string EscapeTypeNameForIdentifier(string typeName, bool stripGlob /// public static (uint Data1, ushort Data2, ushort Data3, byte[] Data4)? GetGuidFields(TypeDefinition type) { - CustomAttribute? attr = type.GetAttribute(WindowsFoundationMetadata, "GuidAttribute"); + CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute("GuidAttribute"); if (attr is null || attr.Signature is null) { diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 0e3295a22..b6fa7ffc5 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -11,7 +11,6 @@ using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -314,7 +313,7 @@ public static void WriteClassObjRefDefinitions(IndentedTextWriter writer, Projec // For FastAbi classes, skip non-default exclusive interfaces -- their methods // dispatch through the default interface's vtable so a separate objref is unnecessary. - bool isDefault = impl.HasAttribute(WindowsFoundationMetadata, DefaultAttribute); + bool isDefault = impl.HasWindowsFoundationMetadataAttribute(DefaultAttribute); if (!isDefault && ClassFactory.IsFastAbiClass(type)) { @@ -342,7 +341,7 @@ public static void WriteClassObjRefDefinitions(IndentedTextWriter writer, Projec } // Same fast-abi guard as the first pass. - bool isDefault2 = impl.HasAttribute(WindowsFoundationMetadata, DefaultAttribute); + bool isDefault2 = impl.HasWindowsFoundationMetadataAttribute(DefaultAttribute); if (!isDefault2 && ClassFactory.IsFastAbiClass(type)) { From 96eb6b65c4cf873fd3fd4013ebed3a9bb4a33c25 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:42:54 -0700 Subject: [PATCH 077/171] R7-15: CustomAttribute.TryGetFixedArgument helper (Try- only) Add `CustomAttribute.TryGetFixedArgument(int index, out T? value)` extension that centralises the `attr.Signature?.FixedArguments[i].Element` unwrap + standard uint->int coercion (used pervasively for WinMD numeric metadata values like ContractVersion and Version). Per the user's caveat for R7-15, only the Try- form was added (no non-Try `GetFixedArgument`). Migrated the two canonical sites: - `TypeDefinitionExtensions.GetContractVersion` (10 lines -> 2) - `TypeDefinitionExtensions.GetVersion` (10 lines -> 2) Sites NOT migrated (intentionally): - `AbiTypeHelpers.cs:51`, `AttributedTypes.cs:97`, `ConstructorFactory.cs:51`, `InterfaceFactory.cs:357`: loop through ALL fixed args, not indexed lookup - `CustomAttributeFactory.cs:325, 397`: Count-only check, no Element read - `ClassFactory.cs GetGCPressure`: reads NamedArguments, not FixedArguments - `AttributedTypes.cs:129`: uses list-pattern matching (already concise) - `IidExpressionGenerator.cs:82`: bulk-extracts the full 11-arg GUID tuple Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/CustomAttributeExtensions.cs | 56 +++++++++++++++++++ .../Extensions/TypeDefinitionExtensions.cs | 46 +-------------- 2 files changed, 58 insertions(+), 44 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs b/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs new file mode 100644 index 000000000..6b2eb5c40 --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs @@ -0,0 +1,56 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System.Diagnostics.CodeAnalysis; +using AsmResolver.DotNet; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class CustomAttributeExtensions +{ + extension(CustomAttribute attr) + { + /// + /// Attempts to read the boxed fixed-positional argument at from + /// , applying the standard uint↔int + /// coercion when is and the boxed value is + /// . Returns when the attribute has no signature, + /// the index is out of range, or the boxed value cannot be converted to . + /// + /// The expected argument type (e.g. , , + /// ). + /// The zero-based positional argument index. + /// The argument value when this returns ; otherwise default. + /// on successful conversion; otherwise . + public bool TryGetFixedArgument(int index, [NotNullWhen(true)] out T? value) + { + if (attr.Signature is null || index < 0 || index >= attr.Signature.FixedArguments.Count) + { + value = default; + return false; + } + + object? element = attr.Signature.FixedArguments[index].Element; + + if (element is T t) + { + value = t; + return true; + } + + // Standard coercion: uint -> int (WinMD often stores numeric metadata values as uint + // in the fixed-args list, but most call sites consume them as int). + if (typeof(T) == typeof(int) && element is uint u) + { + value = (T)(object)(int)u; + return true; + } + + value = default; + return false; + } + } +} diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 309c9f166..b19437c12 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -89,28 +89,7 @@ public bool HasDefaultConstructor() public int? GetContractVersion() { CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute(ContractVersionAttribute); - - if (attr is null) - { - return null; - } - - if (attr.Signature is not null && attr.Signature.FixedArguments.Count > 1) - { - object? v = attr.Signature.FixedArguments[1].Element; - - if (v is uint u) - { - return (int)u; - } - - if (v is int i) - { - return i; - } - } - - return null; + return attr is not null && attr.TryGetFixedArgument(1, out int v) ? v : null; } /// @@ -122,28 +101,7 @@ public bool HasDefaultConstructor() public int? GetVersion() { CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute(VersionAttribute); - - if (attr is null) - { - return null; - } - - if (attr.Signature is not null && attr.Signature.FixedArguments.Count > 0) - { - object? v = attr.Signature.FixedArguments[0].Element; - - if (v is uint u) - { - return (int)u; - } - - if (v is int i) - { - return i; - } - } - - return null; + return attr is not null && attr.TryGetFixedArgument(0, out int v) ? v : null; } } } \ No newline at end of file From 7befc3c2f8824c0b926203e06308c3e7efe40bcd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:45:11 -0700 Subject: [PATCH 078/171] R7-17, R7-18: ParameterCategory.IsArrayInput + TypeSignature.AsSzArray helpers **R7-17**: Add `ParameterCategory.IsArrayInput()` and `IsAnyArray()` extension predicates. `IsArrayInput()` covers `PassArray` or `FillArray`; `IsAnyArray()` adds `ReceiveArray`. Migrated 20 sites of the `cat is ParameterCategory.PassArray or ParameterCategory.FillArray` disjunction (and its negated form) to use `cat.IsArrayInput()`. **R7-18**: Add `TypeSignature.AsSzArray()` and `SzArrayElement()` helpers that wrap `StripByRefAndCustomModifiers` + the `as SzArrayTypeSignature` cast. Migrated 6 sites of the awkward `(SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type)` cast to `p.Type.AsSzArray()!`. Migrated files: - `AbiMethodBodyFactory.DoAbi.cs` (4 + 2) - `AbiMethodBodyFactory.RcwCaller.cs` (8 + 4) - `AbiTypeHelpers.cs` (1) - `ConstructorFactory.FactoryCallbacks.cs` (7) Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ParameterCategoryExtensions.cs | 32 +++++++++++++++++++ .../Extensions/TypeSignatureExtensions.cs | 20 ++++++++++++ .../Factories/AbiMethodBodyFactory.DoAbi.cs | 6 ++-- .../AbiMethodBodyFactory.RcwCaller.cs | 18 +++++------ .../ConstructorFactory.FactoryCallbacks.cs | 8 ++--- .../Helpers/AbiTypeHelpers.cs | 2 +- 6 files changed, 69 insertions(+), 17 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs new file mode 100644 index 000000000..7f85acb0d --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs @@ -0,0 +1,32 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Models; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class ParameterCategoryExtensions +{ + extension(ParameterCategory cat) + { + /// + /// Returns whether is an input-side array category + /// ( or ). + /// + public bool IsArrayInput() + => cat is ParameterCategory.PassArray or ParameterCategory.FillArray; + + /// + /// Returns whether is any of the array-shaped categories + /// (, , + /// or ). + /// + public bool IsAnyArray() + => cat is ParameterCategory.PassArray + or ParameterCategory.FillArray + or ParameterCategory.ReceiveArray; + } +} diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 9d55e7cca..2bf60e154 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -211,5 +211,25 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) || resolver.IsRuntimeClassOrInterface(sig!) || (sig is CorLibTypeSignature corlibObj && corlibObj.ElementType == ElementType.Object); } + + /// + /// Strips byref + custom modifiers from and returns the result + /// as an if the underlying type is one; otherwise + /// returns . + /// + public SzArrayTypeSignature? AsSzArray() + { + return Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig!) as SzArrayTypeSignature; + } + + /// + /// Returns the element type of the underlying SZ-array (after stripping byref + + /// custom modifiers), or if the underlying type is not an + /// . + /// + public TypeSignature? SzArrayElement() + { + return (Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig!) as SzArrayTypeSignature)?.BaseType; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index ab56553df..79b33b4c1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -119,7 +119,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } string raw = p.GetRawName(); - SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + SzArrayTypeSignature sza = p.Type.AsSzArray()!; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); @@ -225,7 +225,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); - SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + SzArrayTypeSignature sza = p.Type.AsSzArray()!; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); writer.WriteLine(isMultiline: true, $$""" *{{ptr}} = default; @@ -460,7 +460,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection writer.Write($"*{ptr}"); } } - else if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + else if (cat.IsArrayInput()) { string raw = p.GetRawName(); writer.Write($"__{raw}"); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index bf5a2c8b7..97b102272 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -59,7 +59,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput()) { _ = fp.Append(", uint, void*"); continue; @@ -117,7 +117,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.ReceiveArray) { - SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + SzArrayTypeSignature sza = p.Type.AsSzArray()!; _ = fp.Append(", uint*, "); if (sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) @@ -389,7 +389,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + SzArrayTypeSignature sza = p.Type.AsSzArray()!; writer.WriteLine(isMultiline: true, $$""" uint __{{localName}}_length = default; @@ -545,7 +545,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if ((cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput() && p.Type is SzArrayTypeSignature szArrCheck && !context.AbiTypeShapeResolver.IsBlittableAbiElement(szArrCheck.BaseType) && !context.AbiTypeShapeResolver.IsMappedAbiValueType(szArrCheck.BaseType)) @@ -654,7 +654,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput()) { // All PassArrays (including complex structs) go in the void* combined block, // matching truth's pattern. Complex structs use a (T*) cast at the call site. @@ -704,7 +704,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); bool isString = p.Type.IsString(); bool isType = p.Type.IsSystemType(); - bool isPassArray = cat is ParameterCategory.PassArray or ParameterCategory.FillArray; + bool isPassArray = cat.IsArrayInput(); if (!isString && !isType && !isPassArray) { @@ -896,7 +896,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput()) { string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); @@ -1168,7 +1168,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + SzArrayTypeSignature sza = p.Type.AsSzArray()!; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); // Element ABI type: void* for ref types (string/runtime class/object); ABI struct // type for complex structs (e.g. authored BasicStruct); blittable struct ABI for @@ -1511,7 +1511,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - SzArrayTypeSignature sza = (SzArrayTypeSignature)AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + SzArrayTypeSignature sza = p.Type.AsSzArray()!; // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. (Same categorization as the ConvertToManaged_ path.) string elementAbi = sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 9ba2a6eb5..17597b653 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -337,7 +337,7 @@ public override unsafe void Invoke( { pinnableCount++; } - else if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + else if (cat.IsArrayInput()) { pinnableCount++; } @@ -354,7 +354,7 @@ public override unsafe void Invoke( ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); bool isStr = p.Type.IsString(); bool isType = p.Type.IsSystemType(); - bool isArr = cat is ParameterCategory.PassArray or ParameterCategory.FillArray; + bool isArr = cat.IsArrayInput(); if (!isStr && !isType && !isArr) { @@ -472,7 +472,7 @@ public override unsafe void Invoke( ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput()) { writer.Write("uint, void*, "); continue; @@ -499,7 +499,7 @@ public override unsafe void Invoke( , """); - if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput()) { writer.Write($"(uint){pname}.Length, _{raw}"); continue; diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 5d2895df1..1254f1200 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -215,7 +215,7 @@ internal static bool IsDelegateInvokeNativeSupported(MetadataCache cache, Method { ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is ParameterCategory.PassArray or ParameterCategory.FillArray) + if (cat.IsArrayInput()) { if (p.Type is SzArrayTypeSignature szP) { From 863859132ad618aa74b8424eb380c724e5157a3f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:46:57 -0700 Subject: [PATCH 079/171] R7-19: Promote GetParamLocalName/GetParamName to ParameterInfo extensions Move `AbiTypeHelpers.GetParamName(ParameterInfo, string?)` and `AbiTypeHelpers.GetParamLocalName(ParameterInfo, string?)` to `ParameterInfoExtensions` so callsites read `p.GetParamName(override)` and `p.GetParamLocalName(override)` instead of `AbiTypeHelpers.GetParamName(p, override)`. Colocated with the existing `GetRawName` / `GetEscapedName` extensions in `Models\ParameterInfoExtensions.cs`, then deleted the original static helpers from `Helpers\AbiTypeHelpers.cs`. 52 call sites migrated (all in `AbiMethodBodyFactory.RcwCaller.cs`). Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AbiMethodBodyFactory.RcwCaller.cs | 100 +++++++++--------- .../Helpers/AbiTypeHelpers.cs | 27 ----- .../Models/ParameterInfoExtensions.cs | 27 +++++ 3 files changed, 77 insertions(+), 77 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 97b102272..a50501926 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -262,16 +262,16 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject()) { - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); EmitMarshallerConvertToUnmanagedCallback cvt = EmitMarshallerConvertToUnmanaged(context, p.Type, callName); writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{localName} = {cvt};"); } else if (p.Type.IsNullableT()) { // Nullable param: use Marshaller.BoxToUnmanaged. - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); TypeSignature inner = p.Type.GetNullableInnerType()!; string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{localName} = {innerMarshaller}.BoxToUnmanaged({callName});"); @@ -279,8 +279,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else if (p.Type.IsGenericInstance()) { // Generic instance param: emit a local UnsafeAccessor delegate to get the marshaller method. - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" @@ -308,8 +308,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); writer.WriteLine($" global::ABI.System.Exception __{localName} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({callName});"); } @@ -328,8 +328,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); writer.WriteLine($" {AbiTypeHelpers.GetMappedAbiTypeName(p.Type)} __{localName} = {AbiTypeHelpers.GetMappedMarshallerName(p.Type)}.ConvertToUnmanaged({callName});"); } @@ -354,7 +354,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(writer, context, pType)} __{localName} = default;"); } @@ -369,7 +369,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); writer.Write(" "); @@ -388,7 +388,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; writer.WriteLine(isMultiline: true, $$""" uint __{{localName}}_length = default; @@ -427,8 +427,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // For mapped value types (DateTime/TimeSpan), use the ABI struct type. // For complex structs (e.g. authored BasicStruct with reference fields), use the ABI // struct type. For everything else (runtime classes, objects, strings), use nint. - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); string storageT = context.AbiTypeShapeResolver.IsMappedAbiValueType(szArr.BaseType) ? AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) : context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType) @@ -602,8 +602,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); writer.WriteLine($"{indent}__{localName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, pType)}.ConvertToUnmanaged({callName});"); } @@ -623,8 +623,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); + string callName = p.GetParamName(paramNameOverride); writer.WriteLine($"{indent}global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({callName}, out TypeReference __{localName});"); } @@ -680,8 +680,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRef = uRefSkip; string abiType = context.AbiTypeShapeResolver.IsBlittableStruct(uRef) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, uRef) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uRef); writer.WriteLine($"{indent}{new string(' ', fixedNesting * 4)}fixed({abiType}* _{localName} = &{callName})"); @@ -711,8 +711,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); writer.WriteIf(!first, ", "); @@ -765,8 +765,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(sig.Parameters[i], paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(sig.Parameters[i], paramNameOverride); + string callName = sig.Parameters[i].GetParamName(paramNameOverride); + string localName = sig.Parameters[i].GetParamLocalName(paramNameOverride); writer.WriteLine($"{indent}{new string(' ', fixedNesting * 4)}HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{localName}, {callName}?.Length, out HStringReference __{localName});"); } stringPinnablesEmitted = true; @@ -809,8 +809,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); if (szArr.BaseType.IsString()) { @@ -898,8 +898,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat.IsArrayInput()) { - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); writer.Write(isMultiline: true, $$""" , (uint){{callName}}.Length, _{{localName}} @@ -909,7 +909,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.Out) { - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); writer.Write(isMultiline: true, $$""" , &__{{localName}} @@ -919,7 +919,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.ReceiveArray) { - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); writer.Write(isMultiline: true, $$""" , &__{{localName}}_length, &__{{localName}}_data @@ -929,7 +929,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.Ref) { - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRefArg = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); if (context.AbiTypeShapeResolver.IsComplexStruct(uRefArg)) @@ -956,34 +956,34 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec """); if (p.Type.IsHResultException()) { - writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}"); + writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); } else if (p.Type.IsString()) { - writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}.HString"); + writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.HString"); } else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject() || p.Type.IsGenericInstance()) { - writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}.GetThisPtrUnsafe()"); + writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.GetThisPtrUnsafe()"); } else if (p.Type.IsSystemType()) { // System.Type input: pass the pre-converted ABI Type struct (via the local set up before the call). - writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}.ConvertToUnmanagedUnsafe()"); + writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.ConvertToUnmanagedUnsafe()"); } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) { // Mapped value-type input: pass the pre-converted ABI local. - writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}"); + writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); } else if (context.AbiTypeShapeResolver.IsComplexStruct(p.Type)) { // Complex struct input: pass the pre-converted ABI struct local. - writer.Write($"__{AbiTypeHelpers.GetParamLocalName(p, paramNameOverride)}"); + writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); } else if (context.AbiTypeShapeResolver.IsBlittableStruct(p.Type)) { - writer.Write(AbiTypeHelpers.GetParamName(p, paramNameOverride)); + writer.Write(p.GetParamName(paramNameOverride)); } else { @@ -1036,8 +1036,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); // Determine the ABI element type for the data pointer parameter. // - Strings / runtime classes / objects: void** @@ -1088,8 +1088,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); // For Out generic instance: emit inline UnsafeAccessor to ConvertToManaged_ @@ -1166,8 +1166,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string callName = AbiTypeHelpers.GetParamName(p, paramNameOverride); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string callName = p.GetParamName(paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); // Element ABI type: void* for ref types (string/runtime class/object); ABI struct @@ -1329,7 +1329,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); writer.WriteLine($" {AbiTypeHelpers.GetMarshallerFullName(writer, context, pType)}.Dispose(__{localName});"); } @@ -1368,7 +1368,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // HResultException ABI is just an int; per-element Dispose is a no-op (mirror // the truth: no Dispose_ emitted). Just return the inline-array's pool // using the correct element type (ABI.System.Exception, not nint). - string localNameH = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localNameH = p.GetParamLocalName(paramNameOverride); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" if (__{{localNameH}}_arrayFromPool is not null) @@ -1378,7 +1378,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec """); continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); if (szArr.BaseType.IsString()) { @@ -1479,7 +1479,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); if (uOut.IsString()) { @@ -1510,7 +1510,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - string localName = AbiTypeHelpers.GetParamLocalName(p, paramNameOverride); + string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. (Same categorization as the ConvertToManaged_ path.) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 1254f1200..251223ae2 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -387,31 +387,4 @@ internal static TypeSignature StripByRefAndCustomModifiers(TypeSignature sig) return current; } } - - /// - /// Returns the C#-callsite name for (the metadata name, escaped with - /// @ when it collides with a C# keyword). When is - /// non-, it replaces the metadata name. - /// - /// The parameter to name. - /// Optional override (FastAbi-merged Methods classes use this to inject a synthesized name). - /// The escaped parameter name. - internal static string GetParamName(ParameterInfo p, string? paramNameOverride) - { - string name = paramNameOverride ?? p.GetRawName(); - return IdentifierEscaping.EscapeIdentifier(name); - } - - /// - /// Returns the local-variable name for (the metadata name without - /// the C#-keyword @ escape, since helper local names like __event are valid - /// even when the underlying parameter name is a C# keyword). - /// - /// The parameter to name. - /// Optional override. - /// The unescaped local-variable name. - internal static string GetParamLocalName(ParameterInfo p, string? paramNameOverride) - { - return paramNameOverride ?? p.GetRawName(); - } } diff --git a/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs b/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs index 2bdeb654f..63ae33de9 100644 --- a/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs +++ b/src/WinRT.Projection.Writer/Models/ParameterInfoExtensions.cs @@ -35,4 +35,31 @@ public static string GetEscapedName(this ParameterInfo parameter, string default { return Helpers.IdentifierEscaping.EscapeIdentifier(parameter.Parameter.Name ?? defaultName); } + + /// + /// Returns the C#-escaped parameter name, allowing the caller to inject a synthesized + /// override (e.g. FastAbi-merged Methods classes). When + /// is non-, it replaces the metadata name as the source for escaping. + /// + /// The parameter to name. + /// Optional override; takes precedence over the metadata name when non-. + /// The escaped parameter name (with @ prefix for C# keywords). + public static string GetParamName(this ParameterInfo parameter, string? paramNameOverride) + { + string name = paramNameOverride ?? parameter.GetRawName(); + return Helpers.IdentifierEscaping.EscapeIdentifier(name); + } + + /// + /// Returns the local-variable name for : the raw metadata + /// name (no C#-keyword @ escape, since helper locals like __event remain + /// valid identifiers even when the underlying parameter name is a C# keyword). + /// + /// The parameter to name. + /// Optional override; takes precedence over the metadata name when non-. + /// The unescaped local-variable name. + public static string GetParamLocalName(this ParameterInfo parameter, string? paramNameOverride) + { + return paramNameOverride ?? parameter.GetRawName(); + } } From 488b593cef04312149da2ffb9b0caeea8fd5fce3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:49:07 -0700 Subject: [PATCH 080/171] R7-20, R7-22, R7-23: HasNonObjectBaseType/HasNonProjectionBaseClass + MatchesName + WellKnownAbiTypeNames **R7-22**: Add `ITypeDefOrRef.MatchesName(string ns, string name)` extension that wraps the verbose `type.Namespace?.Value == ns && type.Name?.Value == name` double-null-coalesce. Used internally by R7-20. **R7-20**: Add two `TypeDefinition` predicates built on R7-22: - `HasNonObjectBaseType()`: base type that is not `System.Object`. - `HasNonProjectionBaseClass()`: base type that is neither `System.Object` nor `WindowsRuntime.WindowsRuntimeObject`. Migrated 2 sites: - `ClassMembersFactory.WriteInterfaceMembers.cs:126` (uses `HasNonObjectBaseType`) - `ClassFactory.cs:712` (uses `HasNonProjectionBaseClass`) **R7-23**: Add `WellKnownAbiTypeNames` constants for the literal-string `"global::ABI.System.*"` ABI type names emitted as projection source. Constants: `AbiSystemType`, `AbiSystemTypePointer`, `AbiSystemException`, `AbiSystemExceptionPointer`, `AbiSystemExceptionPointerData`, `AbiSystemDateTimeOffset`, `AbiSystemTimeSpan`, `AbiSystemTypeMarshaller`, `AbiSystemExceptionMarshaller`. Migrated 17 sites across 4 files (only the bare literals; interpolated `$"global::ABI.System.{X}Marshaller.ConvertTo{Y}(...)"` left alone). Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ITypeDefOrRefExtensions.cs | 11 ++++++ .../Extensions/TypeDefinitionExtensions.cs | 20 ++++++++++ .../Factories/AbiMethodBodyFactory.DoAbi.cs | 4 +- .../AbiMethodBodyFactory.RcwCaller.cs | 24 ++++++------ .../Factories/ClassFactory.cs | 4 +- ...assMembersFactory.WriteInterfaceMembers.cs | 4 +- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 6 ++- .../Helpers/AbiTypeWriter.cs | 18 +++++---- .../References/WellKnownAbiTypeNames.cs | 39 +++++++++++++++++++ 9 files changed, 102 insertions(+), 28 deletions(-) create mode 100644 src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index fc80768fc..492ba2c39 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -74,5 +74,16 @@ internal static class ITypeDefOrRefExtensions return null; } + + /// + /// Returns whether 's namespace and name match + /// (, ). + /// + /// The expected namespace. + /// The expected unqualified type name. + public bool MatchesName(string ns, string name) + { + return type.Namespace?.Value == ns && type.Name?.Value == name; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index b19437c12..94d8a231e 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -80,6 +80,26 @@ public bool HasDefaultConstructor() return false; } + /// + /// Returns whether the type has a base type that is not + /// (i.e. the type derives from a real WinRT/.NET class). + /// + public bool HasNonObjectBaseType() + { + return type.BaseType is { } bt && !bt.MatchesName("System", "Object"); + } + + /// + /// Returns whether the type has a base type that is neither + /// nor the projection's WindowsRuntime.WindowsRuntimeObject root. + /// + public bool HasNonProjectionBaseClass() + { + return type.BaseType is { } bt + && !bt.MatchesName("System", "Object") + && !bt.MatchesName("WindowsRuntime", "WindowsRuntimeObject"); + } + /// /// Returns the second positional argument (a ) of /// [Windows.Foundation.Metadata.ContractVersionAttribute] on the type, or diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 79b33b4c1..6ca504f71 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -12,6 +12,8 @@ using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; +using WindowsRuntime.ProjectionWriter.References; + namespace WindowsRuntime.ProjectionWriter.Factories; internal static partial class AbiMethodBodyFactory @@ -599,7 +601,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else if (szFA.BaseType.IsHResultException()) { - dataParamType = "global::ABI.System.Exception* data"; + dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointerData; dataCastType = "(global::ABI.System.Exception*)"; } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(szFA.BaseType)) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index a50501926..31123975e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -15,6 +15,8 @@ using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; +using WindowsRuntime.ProjectionWriter.References; + namespace WindowsRuntime.ProjectionWriter.Factories; internal static partial class AbiMethodBodyFactory @@ -76,7 +78,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (uOut.IsSystemType()) { - _ = fp.Append("global::ABI.System.Type*"); + _ = fp.Append(WellKnownAbiTypeNames.AbiSystemTypePointer); } else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) { @@ -126,7 +128,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (sza.BaseType.IsHResultException()) { - _ = fp.Append("global::ABI.System.Exception"); + _ = fp.Append(WellKnownAbiTypeNames.AbiSystemException); } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(sza.BaseType)) { @@ -151,7 +153,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (p.Type.IsHResultException()) { - _ = fp.Append("global::ABI.System.Exception"); + _ = fp.Append(WellKnownAbiTypeNames.AbiSystemException); } else if (p.Type.IsAbiRefLike(context.AbiTypeShapeResolver)) { @@ -159,7 +161,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (p.Type.IsSystemType()) { - _ = fp.Append("global::ABI.System.Type"); + _ = fp.Append(WellKnownAbiTypeNames.AbiSystemType); } else if (context.AbiTypeShapeResolver.IsBlittableStruct(p.Type)) { @@ -194,7 +196,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (retSz.BaseType.IsHResultException()) { - _ = fp.Append("global::ABI.System.Exception"); + _ = fp.Append(WellKnownAbiTypeNames.AbiSystemException); } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType)) { @@ -225,7 +227,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (rt is not null && rt.IsSystemType()) { - _ = fp.Append("global::ABI.System.Type*"); + _ = fp.Append(WellKnownAbiTypeNames.AbiSystemTypePointer); } else if (returnIsBlittableStruct) { @@ -434,7 +436,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType) : szArr.BaseType.IsHResultException() - ? "global::ABI.System.Exception" + ? WellKnownAbiTypeNames.AbiSystemException : "nint"; writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" @@ -856,7 +858,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (szArr.BaseType.IsHResultException()) { - dataParamType = "global::ABI.System.Exception*"; + dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointer; dataCastType = "(global::ABI.System.Exception*)"; } else if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) @@ -1054,7 +1056,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (szFA.BaseType.IsHResultException()) { - dataParamType = "global::ABI.System.Exception* data"; + dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointerData; dataCastType = "(global::ABI.System.Exception*)"; } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(szFA.BaseType)) @@ -1199,7 +1201,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType) : retSz.BaseType.IsHResultException() - ? "global::ABI.System.Exception" + ? WellKnownAbiTypeNames.AbiSystemException : context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType) ? AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType) : context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType) @@ -1556,7 +1558,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType) : retSz.BaseType.IsHResultException() - ? "global::ABI.System.Exception" + ? WellKnownAbiTypeNames.AbiSystemException : context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType) ? AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType) : context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index a4c67c422..e454a4b8a 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -708,9 +708,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont } // base call when type has a non-object base class - bool hasBaseClass = type.BaseType is not null - && !(type.BaseType.Namespace?.Value == "System" && type.BaseType.Name?.Value == "Object") - && !(type.BaseType.Namespace?.Value == "WindowsRuntime" && type.BaseType.Name?.Value == "WindowsRuntimeObject"); + bool hasBaseClass = type.HasNonProjectionBaseClass(); if (hasBaseClass) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 398296aff..5cdbf0ed6 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -121,9 +121,7 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr if (classType.BaseType is not null) { - string? baseNs = classType.BaseType.Namespace?.Value; - string? baseName = classType.BaseType.Name?.Value; - hasBaseType = !(baseNs == "System" && baseName == "Object"); + hasBaseType = classType.HasNonObjectBaseType(); } writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index d848f8144..45b8b3465 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -10,6 +10,8 @@ using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; +using WindowsRuntime.ProjectionWriter.References; + namespace WindowsRuntime.ProjectionWriter.Helpers; internal static partial class AbiTypeHelpers @@ -36,12 +38,12 @@ internal static string GetAbiLocalTypeName(IndentedTextWriter writer, Projection if (sig.IsSystemType()) { - return "global::ABI.System.Type"; + return WellKnownAbiTypeNames.AbiSystemType; } if (sig.IsHResultException()) { - return "global::ABI.System.Exception"; + return WellKnownAbiTypeNames.AbiSystemException; } if (context.AbiTypeShapeResolver.IsComplexStruct(sig)) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 865d8242b..e24a1a9f4 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -11,6 +11,8 @@ using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; using static WindowsRuntime.ProjectionWriter.References.WellKnownTypeNames; +using WindowsRuntime.ProjectionWriter.References; + namespace WindowsRuntime.ProjectionWriter.Helpers; /// @@ -51,19 +53,19 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext // (DateTime/TimeSpan -> ABI.System.DateTimeOffset/TimeSpan). if (dNs == WindowsFoundation && dName == "DateTime") { - writer.Write("global::ABI.System.DateTimeOffset"); + writer.Write(WellKnownAbiTypeNames.AbiSystemDateTimeOffset); break; } if (dNs == WindowsFoundation && dName == "TimeSpan") { - writer.Write("global::ABI.System.TimeSpan"); + writer.Write(WellKnownAbiTypeNames.AbiSystemTimeSpan); break; } if (dNs == WindowsFoundation && dName == HResult) { - writer.Write("global::ABI.System.Exception"); + writer.Write(WellKnownAbiTypeNames.AbiSystemException); break; } @@ -71,7 +73,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext { // System.Type ABI struct: maps to global::ABI.System.Type, not the // ABI.Windows.UI.Xaml.Interop.TypeName form. - writer.Write("global::ABI.System.Type"); + writer.Write(WellKnownAbiTypeNames.AbiSystemType); break; } @@ -104,19 +106,19 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext // Special case: mapped value types that require ABI marshalling. if (rns == WindowsFoundation && rname == "DateTime") { - writer.Write("global::ABI.System.DateTimeOffset"); + writer.Write(WellKnownAbiTypeNames.AbiSystemDateTimeOffset); break; } if (rns == WindowsFoundation && rname == "TimeSpan") { - writer.Write("global::ABI.System.TimeSpan"); + writer.Write(WellKnownAbiTypeNames.AbiSystemTimeSpan); break; } if (rns == WindowsFoundation && rname == HResult) { - writer.Write("global::ABI.System.Exception"); + writer.Write(WellKnownAbiTypeNames.AbiSystemException); break; } @@ -151,7 +153,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext if (rdNs == WindowsFoundation && rdName == HResult) { - writer.Write("global::ABI.System.Exception"); + writer.Write(WellKnownAbiTypeNames.AbiSystemException); break; } diff --git a/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs b/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs new file mode 100644 index 000000000..75d77053d --- /dev/null +++ b/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs @@ -0,0 +1,39 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.References; + +/// +/// Well-known ABI type names emitted as literals in projection source. Each constant is the +/// fully-qualified C# expression (with the global:: prefix) for the corresponding +/// type as referenced from generated code. +/// +internal static class WellKnownAbiTypeNames +{ + /// The global::ABI.System.Type ABI helper struct. + public const string AbiSystemType = "global::ABI.System.Type"; + + /// The global::ABI.System.Type* pointer-to-ABI form. + public const string AbiSystemTypePointer = "global::ABI.System.Type*"; + + /// The global::ABI.System.Exception ABI helper struct. + public const string AbiSystemException = "global::ABI.System.Exception"; + + /// The global::ABI.System.Exception* pointer-to-ABI form. + public const string AbiSystemExceptionPointer = "global::ABI.System.Exception*"; + + /// The global::ABI.System.Exception* data parameter signature. + public const string AbiSystemExceptionPointerData = "global::ABI.System.Exception* data"; + + /// The global::ABI.System.DateTimeOffset ABI helper struct. + public const string AbiSystemDateTimeOffset = "global::ABI.System.DateTimeOffset"; + + /// The global::ABI.System.TimeSpan ABI helper struct. + public const string AbiSystemTimeSpan = "global::ABI.System.TimeSpan"; + + /// The global::ABI.System.TypeMarshaller static class. + public const string AbiSystemTypeMarshaller = "global::ABI.System.TypeMarshaller"; + + /// The global::ABI.System.ExceptionMarshaller static class. + public const string AbiSystemExceptionMarshaller = "global::ABI.System.ExceptionMarshaller"; +} From 6f8ccdaf0636251b05be99fb8088c2ae7d949748 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:50:38 -0700 Subject: [PATCH 081/171] R7-27: ITypeDefOrRef.TryGetGenericInstance helper Add `ITypeDefOrRef.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)` extension that wraps the dual-pattern check `X is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi` in a single Try- call. Marked with [NotNullWhen(true)] so callers get non-null `gi` flow. Migrated 9 sites where only `gi` (not the outer `ts`) is used: - `AbiMethodBodyFactory.MethodsClass.cs:28` - `ObjRefNameGenerator.cs:91, 140, 452` (+ another) - `InterfaceFactory.cs:166` - `ClassMembersFactory.WriteInterfaceMembers.cs:62` - `ClassMembersFactory.cs:81, 147` Sites NOT migrated: - `AbiInterfaceIDicFactory.cs:111, 125`: include an additional `TypeArguments.Count` predicate inline -- not a clean fit. - `ITypeDefOrRefExtensions.cs:63`: this is the canonical `ResolveAsTypeDefinition` implementation -- migrating would create a circular helper call. - `TypeSemantics.cs:198`, `ObjRefNameGenerator.cs:381`: structural variants that take a different path. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ITypeDefOrRefExtensions.cs | 13 +++++++++++++ .../Factories/AbiMethodBodyFactory.MethodsClass.cs | 2 +- .../ClassMembersFactory.WriteInterfaceMembers.cs | 2 +- .../Factories/ClassMembersFactory.cs | 4 ++-- .../Factories/InterfaceFactory.cs | 2 +- .../Helpers/ObjRefNameGenerator.cs | 6 +++--- 6 files changed, 21 insertions(+), 8 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index 492ba2c39..e20993663 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System.Diagnostics.CodeAnalysis; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Metadata; @@ -85,5 +86,17 @@ public bool MatchesName(string ns, string name) { return type.Namespace?.Value == ns && type.Name?.Value == name; } + + /// + /// Attempts to extract the from + /// when it is a whose signature + /// is a generic instance. Returns otherwise. + /// + /// The extracted signature when this returns ; otherwise . + public bool TryGetGenericInstance([NotNullWhen(true)] out GenericInstanceTypeSignature? genericInstance) + { + genericInstance = (type as TypeSpecification)?.Signature as GenericInstanceTypeSignature; + return genericInstance is not null; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 3ab319481..6032dbbb3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -25,7 +25,7 @@ internal static partial class AbiMethodBodyFactory /// internal static void EmitUnsafeAccessorForDefaultIfaceIfGeneric(IndentedTextWriter writer, ProjectionEmitContext context, ITypeDefOrRef? defaultIface) { - if (defaultIface is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + if (defaultIface is not null && defaultIface.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { ObjRefNameGenerator.EmitUnsafeAccessorForIid(writer, context, gi); } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 5cdbf0ed6..4f381d739 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -59,7 +59,7 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr ITypeDefOrRef substitutedInterface = impl.Interface; GenericInstanceTypeSignature? nextInstance = null; - if (impl.Interface is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + if (impl.Interface.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { if (currentInstance is not null) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index a447c38cf..3bb6d6895 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -78,7 +78,7 @@ internal static bool IsInterfaceInInheritanceList(MetadataCache cache, Interface return cache.Find(fullName); } - if (typeRef is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + if (typeRef.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { return ResolveInterface(cache, gi.GenericType); } @@ -144,7 +144,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro writer.Write($"global::{ns}.{IdentifierEscaping.StripBackticks(name)}"); } - else if (ifaceType is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + else if (ifaceType.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { ITypeDefOrRef gt = gi.GenericType; (string ns, string name) = gt.Names(); diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index f376c0181..5d4f43e6a 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -163,7 +163,7 @@ public static void WriteInterfaceTypeName(IndentedTextWriter writer, ProjectionE writer.Write(IdentifierEscaping.StripBackticks(name)); } - else if (ifaceType is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + else if (ifaceType.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { ITypeDefOrRef gt = gi.GenericType; (string ns, string name) = gt.Names(); diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index b6fa7ffc5..248675ef8 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -88,7 +88,7 @@ private static void WriteFullyQualifiedInterfaceName(IndentedTextWriter writer, writer.Write(IdentifierEscaping.StripBackticks(name)); } - else if (ifaceType is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + else if (ifaceType.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { ITypeDefOrRef gt = gi.GenericType; (string ns, string name) = gt.Names(); @@ -137,7 +137,7 @@ private static string WriteFullyQualifiedInterfaceName(ProjectionEmitContext con public static void WriteIidExpression(IndentedTextWriter writer, ProjectionEmitContext context, ITypeDefOrRef ifaceType) { // Generic instantiation: use the UnsafeAccessor extern method declared above the field. - if (ifaceType is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + if (ifaceType.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { string propName = BuildIidPropertyNameForGenericInterface(context, gi); writer.Write($"{propName}(null)"); @@ -449,7 +449,7 @@ private static void EmitTransitiveInterfaceObjRefs(IndentedTextWriter writer, Pr // Compute a substitution context if the parent is a closed generic instance. GenericContext? ctx = null; - if (ifaceRef is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + if (ifaceRef.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { ctx = new GenericContext(gi, null); } From 5a76f0a6160d5384d90058e5a468a2f388a4c7d6 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:52:53 -0700 Subject: [PATCH 082/171] R7-30, R7-31, R7-32: Small MethodDefinition + AbiTypeShapeKind helpers **R7-30**: Add `MethodDefinition.GetRawName()` extension that returns `method.Name?.Value ?? string.Empty`. Migrated 10 sites where the `method.Name?.Value ?? string.Empty` pattern was repeated. **R7-31**: Add `MethodDefinition.IsParameterless()` and `IsDefaultConstructor()` predicates. `IsDefaultConstructor` composes `IsConstructor() && IsParameterless()`. Used to simplify `TypeDefinition.HasDefaultConstructor` body. **R7-32**: Add `AbiTypeShapeKind.IsReferenceType()` extension that collapses the `returnShape is RuntimeClassOrInterface or Delegate or Object or GenericInstance or NullableT` disjunction at `AbiMethodBodyFactory.RcwCaller.cs:46`. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/AbiTypeShapeKindExtensions.cs | 27 +++++++++++++++++++ .../Extensions/MethodDefinitionExtensions.cs | 21 +++++++++++++++ .../Extensions/TypeDefinitionExtensions.cs | 2 +- .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiInterfaceIDicFactory.cs | 4 +-- .../AbiMethodBodyFactory.MethodsClass.cs | 2 +- .../AbiMethodBodyFactory.RcwCaller.cs | 2 +- .../Factories/ClassFactory.cs | 2 +- ...assMembersFactory.WriteInterfaceMembers.cs | 2 +- .../Factories/ComponentFactory.cs | 4 +-- .../Factories/InterfaceFactory.cs | 2 +- .../Helpers/AbiTypeHelpers.cs | 2 +- 12 files changed, 60 insertions(+), 12 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs b/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs new file mode 100644 index 000000000..83aca376f --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs @@ -0,0 +1,27 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using WindowsRuntime.ProjectionWriter.Models; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class AbiTypeShapeKindExtensions +{ + extension(AbiTypeShapeKind kind) + { + /// + /// Returns whether the shape is a reference-type marshalling kind: WinRT runtime classes/interfaces, + /// delegates, generic instantiations, the corlib primitive, or + /// /IReference<T> instantiations. + /// + public bool IsReferenceType() + => kind is AbiTypeShapeKind.RuntimeClassOrInterface + or AbiTypeShapeKind.Delegate + or AbiTypeShapeKind.Object + or AbiTypeShapeKind.GenericInstance + or AbiTypeShapeKind.NullableT; + } +} diff --git a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs index e4de40bfd..acba8a4cb 100644 --- a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs @@ -65,6 +65,27 @@ public bool IsAdder() /// if the method is an event remover; otherwise . public bool IsRemover() => method.IsRemoveOverload(); + /// + /// Returns whether the method declares no parameters. + /// + public bool IsParameterless() + => method.Parameters.Count == 0; + + /// + /// Returns whether the method is a parameterless instance constructor (i.e. a default + /// constructor): runtime-special, name .ctor, no parameters. + /// + public bool IsDefaultConstructor() + => method.IsConstructor() && method.IsParameterless(); + + /// + /// Returns the method's raw metadata name, falling back to when + /// the metadata name is . Convenience for the + /// method.Name?.Value ?? string.Empty pattern that appears at many sites. + /// + public string GetRawName() + => method.Name?.Value ?? string.Empty; + /// /// Returns whether the method carries the [NoExceptionAttribute] or is a /// (event removers are implicitly no-throw). diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 94d8a231e..12f6f510a 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -72,7 +72,7 @@ public bool HasDefaultConstructor() { foreach (MethodDefinition m in type.Methods) { - if (m.IsRuntimeSpecialName && m.Name == ".ctor" && m.Parameters.Count == 0) + if (m.IsDefaultConstructor()) { return true; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 087f7ef1c..57be800b1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -360,7 +360,7 @@ void EmitOneDoAbi(MethodDefinition method) { string vm = AbiTypeHelpers.GetVirtualMethodName(type, method); MethodSignatureInfo sig = new(method); - string mname = method.Name?.Value ?? string.Empty; + string mname = method.GetRawName(); // If this method is an event add accessor, emit the per-event ConditionalWeakTable // before the Do_Abi method. diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index d8791ca9c..611e3e166 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -263,7 +263,7 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented foreach (MethodDefinition method in type.GetNonSpecialMethods()) { MethodSignatureInfo sig = new(method); - string mname = method.Name?.Value ?? string.Empty; + string mname = method.GetRawName(); writer.WriteLine(); WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); @@ -382,7 +382,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite foreach (MethodDefinition method in type.GetNonSpecialMethods()) { MethodSignatureInfo sig = new(method); - string mname = method.Name?.Value ?? string.Empty; + string mname = method.GetRawName(); writer.WriteLine(); writer.Write("unsafe "); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 6032dbbb3..1387e317d 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -51,7 +51,7 @@ internal static void EmitMethodsClassMembersFor(IndentedTextWriter writer, Proje // Emit non-special methods first (output order is unchanged from before; only the slot lookup changes). foreach (MethodDefinition method in type.GetNonSpecialMethods()) { - string mname = method.Name?.Value ?? string.Empty; + string mname = method.GetRawName(); MethodSignatureInfo sig = new(method); writer.Write(isMultiline: true, """ diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 31123975e..47172df54 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -43,7 +43,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec AbiTypeShapeKind returnShape = rt is null ? AbiTypeShapeKind.Unknown : context.AbiTypeShapeResolver.Resolve(rt).Kind; bool returnIsString = returnShape == AbiTypeShapeKind.String; - bool returnIsRefType = returnShape is AbiTypeShapeKind.RuntimeClassOrInterface or AbiTypeShapeKind.Delegate or AbiTypeShapeKind.Object or AbiTypeShapeKind.GenericInstance or AbiTypeShapeKind.NullableT; + bool returnIsRefType = returnShape.IsReferenceType(); bool returnIsBlittableStruct = returnShape == AbiTypeShapeKind.BlittableStruct; bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; bool returnIsReceiveArray = rt is SzArrayTypeSignature retSzCheck diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index e454a4b8a..4869fae66 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -348,7 +348,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection foreach (MethodDefinition method in staticIface.GetNonSpecialMethods()) { MethodSignatureInfo sig = new(method); - string mname = method.Name?.Value ?? string.Empty; + string mname = method.GetRawName(); writer.WriteLine(); writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 4f381d739..b07b675ee 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -250,7 +250,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // Methods foreach (MethodDefinition method in ifaceType.GetNonSpecialMethods()) { - string name = method.Name?.Value ?? string.Empty; + string name = method.GetRawName(); // Track by full signature (name + each param's element-type code) to avoid trivial overload duplicates. // This prevents collapsing distinct overloads like Format(double) and Format(ulong). MethodSignatureInfo sig = new(method, genericContext); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 4c5e5c4ff..00ff598d3 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -167,7 +167,7 @@ private static void WriteFactoryActivatableMethod(IndentedTextWriter writer, Pro return; } - string methodName = method.Name?.Value ?? string.Empty; + string methodName = method.GetRawName(); WriteFactoryMethodParametersCallback typedParams = WriteFactoryMethodParameters(context, method, includeTypes: true); WriteFactoryMethodParametersCallback nameOnlyParams = WriteFactoryMethodParameters(context, method, includeTypes: false); writer.WriteLine(); @@ -185,7 +185,7 @@ private static void WriteStaticFactoryMethod(IndentedTextWriter writer, Projecti return; } - string methodName = method.Name?.Value ?? string.Empty; + string methodName = method.GetRawName(); WriteFactoryReturnTypeCallback retType = WriteFactoryReturnType(context, method); WriteFactoryMethodParametersCallback typedParams = WriteFactoryMethodParameters(context, method, includeTypes: true); WriteFactoryMethodParametersCallback nameOnlyParams = WriteFactoryMethodParameters(context, method, includeTypes: false); diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 5d4f43e6a..62c85028e 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -226,7 +226,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro WriteMethodCustomAttributes(writer, method); WriteProjectionReturnTypeCallback ret = MethodFactory.WriteProjectionReturnType(context, sig); WriteParameterListCallback parms = MethodFactory.WriteParameterList(context, sig); - writer.WriteLine($"{ret} {method.Name?.Value ?? string.Empty}({parms});"); + writer.WriteLine($"{ret} {method.GetRawName()}({parms});"); } foreach (PropertyDefinition prop in type.Properties) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 251223ae2..27fedd87a 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -97,7 +97,7 @@ public static string GetVirtualMethodName(TypeDefinition type, MethodDefinition index++; } - return (method.Name?.Value ?? string.Empty) + "_" + index.ToString(CultureInfo.InvariantCulture); + return method.GetRawName() + "_" + index.ToString(CultureInfo.InvariantCulture); } /// From 5614dccf22ed1d1d88fa4334416181d7e73f6a72 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:55:08 -0700 Subject: [PATCH 083/171] R7-26, R7-35, R7-36: Property accessor set + signature dedup-key + interface walk helpers **R7-26** (skip VisitMembers): Add `TypeDefinition.GetPropertyAccessorSet()` that returns the union of all property get/set methods. Replaces the 13-line `HashSet propertyAccessors = []; foreach...` preamble at `AbiInterfaceFactory.cs:344`. **R7-35**: Add `MethodSignatureInfo.GetDedupeKey(name)` for the sole dedupe-key construction site at `ClassMembersFactory.WriteClassMembers.cs`. Removed the private static `BuildMethodSignatureKey` helper. **R7-36**: Promote `MarkAllRequiredInterfacesVisited` (was a private static in `AbiInterfaceIDicFactory`) to a `TypeDefinition.MarkRequiredInterfacesVisited(cache, visited)` extension. 3 call sites migrated; 2 lines collapsed per site. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeDefinitionExtensions.cs | 45 +++++++++++++++++++ .../Factories/AbiInterfaceFactory.cs | 14 +----- .../Factories/AbiInterfaceIDicFactory.cs | 23 ++-------- .../ClassMembersFactory.WriteClassMembers.cs | 18 -------- ...assMembersFactory.WriteInterfaceMembers.cs | 2 +- .../Models/MethodSignatureInfo.cs | 26 +++++++++++ 6 files changed, 76 insertions(+), 52 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 12f6f510a..cf195f482 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -30,6 +30,51 @@ public IEnumerable GetNonSpecialMethods() } } + /// + /// Returns the set of property accessor methods (get and set) declared by the type's + /// properties. Used to filter "regular" methods (non-property, non-event) when emitting + /// per-method code in interface bodies. + /// + public HashSet GetPropertyAccessorSet() + { + HashSet accessors = []; + + foreach (PropertyDefinition prop in type.Properties) + { + if (prop.GetMethod is MethodDefinition g) + { + _ = accessors.Add(g); + } + + if (prop.SetMethod is MethodDefinition s) + { + _ = accessors.Add(s); + } + } + + return accessors; + } + + /// + /// Adds all directly-required interfaces of to + /// so they aren't re-emitted as forwarders. Used by the DIC + /// shim emitters that already cover their inherited interface members transitively + /// (e.g. IBindableVector already includes IBindableIterable's members). + /// + /// The metadata cache used to resolve interface references. + /// The accumulator set to which resolved required interface + /// definitions are added. + public void MarkRequiredInterfacesVisited(Metadata.MetadataCache cache, HashSet visited) + { + foreach (InterfaceImplementation impl in type.Interfaces) + { + if (impl.TryResolveTypeDef(cache, out TypeDefinition? required)) + { + _ = visited.Add(required); + } + } + } + /// /// Returns the [Default] interface of the type (the interface whose vtable backs the /// type's IInspectable identity), or if the type does not declare one. diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 57be800b1..fd9aeee6f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -341,19 +341,7 @@ public static nint Vtable // Build sets of property accessors and event accessors so the first loop below can // iterate "regular" methods (non-property, non-event) only. Do_Abi bodies are emitted in // this order: methods first, then properties (setter before getter), then events. - HashSet propertyAccessors = []; - foreach (PropertyDefinition prop in type.Properties) - { - if (prop.GetMethod is MethodDefinition g) - { - _ = propertyAccessors.Add(g); - } - - if (prop.SetMethod is MethodDefinition s) - { - _ = propertyAccessors.Add(s); - } - } + HashSet propertyAccessors = type.GetPropertyAccessorSet(); // Local helper to emit a single Do_Abi method body for a given MethodDefinition. void EmitOneDoAbi(MethodDefinition method) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 611e3e166..1ce993dd9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -97,7 +97,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( // required interfaces so any other (deeper) inherited mapped interface is covered. if (rName == "IBindableVector") { - MarkAllRequiredInterfacesVisited(context, required, visited); + required.MarkRequiredInterfacesVisited(context.Cache, visited); } continue; @@ -114,7 +114,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( string valueText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[1]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableMapForwarders(writer, context, keyText, valueText); // Mark the inherited IMap`2 / IIterable`1 as visited so they aren't re-emitted. - MarkAllRequiredInterfacesVisited(context, required, visited); + required.MarkRequiredInterfacesVisited(context.Cache, visited); } continue; @@ -126,7 +126,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( { string elementText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giVec.TypeArguments[0]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableVectorForwarders(writer, context, elementText); - MarkAllRequiredInterfacesVisited(context, required, visited); + required.MarkRequiredInterfacesVisited(context.Cache, visited); } continue; @@ -144,23 +144,6 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( } } - /// - /// Adds all directly-required interfaces of to - /// so they aren't re-emitted as forwarders. Used by the shim emitters that already cover their - /// inherited interface members transitively (e.g. IBindableVector already includes - /// IBindableIterable's members). - /// - private static void MarkAllRequiredInterfacesVisited(ProjectionEmitContext context, TypeDefinition required, HashSet visited) - { - foreach (InterfaceImplementation impl2 in required.Interfaces) - { - if (impl2.TryResolveTypeDef(context.Cache, out TypeDefinition? r2)) - { - _ = visited.Add(r2); - } - } - } - /// /// Emits IDictionary<K,V> / ICollection<KVP> / IEnumerable<KVP> + /// IObservableMap<K,V>.MapChanged forwarders for a DIC file interface that inherits diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index 0cee4891f..313262966 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -197,22 +197,4 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo // GetInterface() / GetDefaultInterface() impls are emitted per-interface inside // WriteInterfaceMembersRecursive (matches the original code's per-interface ordering). } - - private static string BuildMethodSignatureKey(string name, MethodSignatureInfo sig) - { - System.Text.StringBuilder sb = new(); - _ = sb.Append(name); - _ = sb.Append('('); - for (int i = 0; i < sig.Parameters.Count; i++) - { - if (i > 0) - { - _ = sb.Append(','); - } - - _ = sb.Append(sig.Parameters[i].Type?.FullName ?? "?"); - } - _ = sb.Append(')'); - return sb.ToString(); - } } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index b07b675ee..cb7b6a87d 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -254,7 +254,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // Track by full signature (name + each param's element-type code) to avoid trivial overload duplicates. // This prevents collapsing distinct overloads like Format(double) and Format(ulong). MethodSignatureInfo sig = new(method, genericContext); - string key = BuildMethodSignatureKey(name, sig); + string key = sig.GetDedupeKey(name); if (!writtenMethods.Add(key)) { diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs index a7de374bc..a8bde87ae 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs @@ -100,4 +100,30 @@ public MethodSignatureInfo(MethodDefinition method, GenericContext? genericConte /// The return parameter name (or default). public string ReturnParameterName(string defaultName = ProjectionNames.DefaultReturnParameterName) => ReturnParameter?.Name?.Value ?? defaultName; + + /// + /// Returns a deduplication key for a method named with this signature: + /// the method name followed by a comma-separated list of parameter type full names enclosed in + /// parentheses. Used to detect duplicate overloads across interface walks. + /// + /// The method's local (un-mangled) name. + public string GetDedupeKey(string name) + { + System.Text.StringBuilder sb = new(); + _ = sb.Append(name); + _ = sb.Append('('); + + for (int i = 0; i < Parameters.Count; i++) + { + if (i > 0) + { + _ = sb.Append(','); + } + + _ = sb.Append(Parameters[i].Type?.FullName ?? "?"); + } + + _ = sb.Append(')'); + return sb.ToString(); + } } From 5415dd88f4d18eb79cb448fbe2d2771bdf674ed8 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 17:59:03 -0700 Subject: [PATCH 084/171] R7-21, R7-29: MethodSignatureInfo.ReturnNameInfo + AbiTypeHelpers.GetNullableInnerInfo **R7-21**: Add `MethodSignatureInfo.ReturnNameInfo` record bundling the three derived return-parameter names (`ValuePointer`, `SizePointer`, `Local`) and `GetReturnNameInfo()` factory. Migrated the canonical 3-line preamble at `AbiMethodBodyFactory.DoAbi.cs:57-63` to use `var retNames = sig.GetReturnNameInfo();`. **R7-29**: Add `AbiTypeHelpers.NullableInnerInfo` record and `GetNullableInnerInfo(writer, context, sig)` helper that returns the inner type + ABI marshaller name as a pair. Collapses the recurring 2-line pattern: TypeSignature inner = X.GetNullableInnerType()!; string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); into a single `(_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, X);` line (the destructured `inner` is unused at all 5 sites). Migrated 5 sites: - `AbiMethodBodyFactory.DoAbi.cs:350, 642` - `AbiMethodBodyFactory.RcwCaller.cs:277, 1229` - `ConstructorFactory.FactoryCallbacks.cs:163` Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 13 +++++----- .../AbiMethodBodyFactory.RcwCaller.cs | 6 ++--- .../ConstructorFactory.FactoryCallbacks.cs | 3 +-- .../Helpers/AbiTypeHelpers.Marshallers.cs | 18 +++++++++++++ .../Models/MethodSignatureInfo.cs | 26 +++++++++++++++++++ 5 files changed, 53 insertions(+), 13 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 6ca504f71..5cb6a02b1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -55,12 +55,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection writer.WriteLine(); using (writer.WriteBlock()) { - string retParamName = AbiTypeHelpers.GetReturnParamName(sig); - string retSizeParamName = AbiTypeHelpers.GetReturnSizeParamName(sig); + MethodSignatureInfo.ReturnNameInfo retNames = sig.GetReturnNameInfo(); + string retParamName = retNames.ValuePointer; + string retSizeParamName = retNames.SizePointer; // The local name for the unmarshalled return value uses the standard pattern // of prefixing '__' to the param name. For the default '__return_value__' param // this becomes '____return_value__'. - string retLocalName = "__" + retParamName; + string retLocalName = retNames.Local; // at the TOP of the method body (before local declarations and the try block). The // actual call sites later in the body just reference the already-declared accessor. // For a generic-instance return type, the accessor is named ConvertToUnmanaged_. @@ -346,8 +347,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Nullable param (server-side): use Marshaller.UnboxToManaged. string rawName = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(rawName); - TypeSignature inner = p.Type.GetNullableInnerType()!; - string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); + (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); writer.WriteLine($" var __arg_{rawName} = {innerMarshaller}.UnboxToManaged({callName});"); } else if (p.Type.IsGenericInstance()) @@ -639,8 +639,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (rt is not null && rt.IsNullableT()) { // Nullable return (server-side): use Marshaller.BoxToUnmanaged. - TypeSignature inner = rt.GetNullableInnerType()!; - string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); + (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, rt); writer.WriteLine($" *{retParamName} = {innerMarshaller}.BoxToUnmanaged({retLocalName}).DetachThisPtrUnsafe();"); } else if (returnIsGenericInstance) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 47172df54..6262cfae6 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -274,8 +274,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Nullable param: use Marshaller.BoxToUnmanaged. string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); - TypeSignature inner = p.Type.GetNullableInnerType()!; - string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); + (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{localName} = {innerMarshaller}.BoxToUnmanaged({callName});"); } else if (p.Type.IsGenericInstance()) @@ -1227,8 +1226,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { // Nullable return: use Marshaller.UnboxToManaged.; // there is no NullableMarshaller, the inner-T marshaller has UnboxToManaged. - TypeSignature inner = rt.GetNullableInnerType()!; - string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); + (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, rt); writer.WriteLine($"{callIndent}return {innerMarshaller}.UnboxToManaged(__retval);"); } else if (rt.IsGenericInstance()) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 17597b653..08ddaf94d 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -160,8 +160,7 @@ public override unsafe void Invoke( if (p.Type.IsNullableT()) { - TypeSignature inner = p.Type.GetNullableInnerType()!; - string innerMarshaller = AbiTypeHelpers.GetNullableInnerMarshallerName(writer, context, inner); + (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{raw} = {innerMarshaller}.BoxToUnmanaged({pname});"); continue; } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs index ff3dcaf89..5b4f7d0cb 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs @@ -77,6 +77,24 @@ internal static bool TryGetNullablePrimitiveMarshallerName(TypeSignature sig, ou return false; } + /// + /// Bundles the inner type of a instantiation together with + /// the ABI marshaller name for that inner type. Returned by + /// . + /// + internal readonly record struct NullableInnerInfo(TypeSignature Inner, string MarshallerName); + + /// + /// Returns the inner type T of Nullable<T> together with its ABI marshaller name. + /// Caller must have verified is a Nullable<T> + /// instantiation (e.g. via IsNullableT). + /// + internal static NullableInnerInfo GetNullableInnerInfo(IndentedTextWriter writer, ProjectionEmitContext context, TypeSignature nullableSig) + { + TypeSignature inner = nullableSig.GetNullableInnerType()!; + return new NullableInnerInfo(inner, GetNullableInnerMarshallerName(writer, context, inner)); + } + /// Returns the marshaller name for the inner type T of Nullable<T>. ///.: e.g. for Nullable<DateTimeOffset> returns /// global::ABI.System.DateTimeOffsetMarshaller; for primitives like Nullable<int> diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs index a8bde87ae..b83f5dfa8 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs @@ -101,6 +101,32 @@ public MethodSignatureInfo(MethodDefinition method, GenericContext? genericConte public string ReturnParameterName(string defaultName = ProjectionNames.DefaultReturnParameterName) => ReturnParameter?.Name?.Value ?? defaultName; + /// + /// Bundles the three derived return-parameter names commonly needed during marshalling code + /// emission: + /// + /// : the (escaped) name of the return-value out-pointer parameter. + /// : the corresponding size out-pointer parameter for receive-array returns. + /// : the conventional __<name> local-variable name for the unmarshalled return value. + /// + /// + /// The return-value pointer parameter name (e.g. __return_value__). + /// The return-value size pointer parameter name (e.g. ____return_value__Size). + /// The local-variable name (e.g. ____return_value__). + public readonly record struct ReturnNameInfo(string ValuePointer, string SizePointer, string Local); + + /// + /// Returns the trio of derived return-parameter names used by Do_Abi / RcwCaller bodies. + /// + public ReturnNameInfo GetReturnNameInfo() + { + string valuePointer = Helpers.AbiTypeHelpers.GetReturnParamName(this); + return new ReturnNameInfo( + ValuePointer: valuePointer, + SizePointer: "__" + valuePointer + "Size", + Local: "__" + valuePointer); + } + /// /// Returns a deduplication key for a method named with this signature: /// the method name followed by a comma-separated list of parameter type full names enclosed in From 1fa798013a31b1a490a9696973705275ee8bdcf7 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 18:03:50 -0700 Subject: [PATCH 085/171] R7-25: ArrayTempNames helper for InlineArray16/ArrayPool naming Add `ArrayTempNames(string Prefix)` record struct that centralises the `__{prefix}_inlineArray` / `__{prefix}_arrayFromPool` / `__{prefix}_span` naming convention used by the inline-array-or-array-pool marshalling stubs (plus the parallel HStringHeader and pinned-handle suffixes for string-array sites). Adopted at all RcwCaller + ConstructorFactory sites that use the canonical `__X_inlineArray`/`_arrayFromPool`/`_span` suffixes. Sites that share the same scope prefix (e.g. `localName`, `raw`) now share a single `ArrayTempNames names = new(prefix);` local, and references inside the multiline raw-string templates use `{names.InlineArray}` etc. instead of `__{prefix}_inlineArray`. DoAbi.cs is NOT migrated: its sites use `__{raw}` (no `_span` suffix) plus an `(int)` cast on the size, so the suffix conventions don't align. Migrating would require either disrupting byte-identical output or further parameterising the helper. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AbiMethodBodyFactory.RcwCaller.cs | 62 ++++++++++--------- .../ConstructorFactory.FactoryCallbacks.cs | 55 ++++++++-------- .../Helpers/ArrayTempNames.cs | 41 ++++++++++++ 3 files changed, 103 insertions(+), 55 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Helpers/ArrayTempNames.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 6262cfae6..67b8b2d5c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -430,6 +430,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // struct type. For everything else (runtime classes, objects, strings), use nint. string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); + ArrayTempNames names = new(localName); string storageT = context.AbiTypeShapeResolver.IsMappedAbiValueType(szArr.BaseType) ? AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) : context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType) @@ -439,11 +440,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : "nint"; writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16<{{storageT}}> __{{localName}}_inlineArray); - {{storageT}}[] __{{localName}}_arrayFromPool = null; - Span<{{storageT}}> __{{localName}}_span = {{callName}}.Length <= 16 - ? __{{localName}}_inlineArray[..{{callName}}.Length] - : (__{{localName}}_arrayFromPool = global::System.Buffers.ArrayPool<{{storageT}}>.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16<{{storageT}}> {{names.InlineArray}}); + {{storageT}}[] {{names.ArrayFromPool}} = null; + Span<{{storageT}}> {{names.Span}} = {{callName}}.Length <= 16 + ? {{names.InlineArray}}[..{{callName}}.Length] + : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool<{{storageT}}>.Shared.Rent({{callName}}.Length)); """); if (szArr.BaseType.IsString() && cat == ParameterCategory.PassArray) @@ -453,17 +454,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // fills HSTRING handles directly into the nint storage. writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16 __{{localName}}_inlineHeaderArray); - HStringHeader[] __{{localName}}_headerArrayFromPool = null; - Span __{{localName}}_headerSpan = {{callName}}.Length <= 16 - ? __{{localName}}_inlineHeaderArray[..{{callName}}.Length] - : (__{{localName}}_headerArrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlineHeaderArray}}); + HStringHeader[] {{names.HeaderArrayFromPool}} = null; + Span {{names.HeaderSpan}} = {{callName}}.Length <= 16 + ? {{names.InlineHeaderArray}}[..{{callName}}.Length] + : ({{names.HeaderArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - Unsafe.SkipInit(out InlineArray16 __{{localName}}_inlinePinnedHandleArray); - nint[] __{{localName}}_pinnedHandleArrayFromPool = null; - Span __{{localName}}_pinnedHandleSpan = {{callName}}.Length <= 16 - ? __{{localName}}_inlinePinnedHandleArray[..{{callName}}.Length] - : (__{{localName}}_pinnedHandleArrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlinePinnedHandleArray}}); + nint[] {{names.PinnedHandleArrayFromPool}} = null; + Span {{names.PinnedHandleSpan}} = {{callName}}.Length <= 16 + ? {{names.InlinePinnedHandleArray}}[..{{callName}}.Length] + : ({{names.PinnedHandleArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); """); } } @@ -812,6 +813,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); + ArrayTempNames names = new(localName); if (szArr.BaseType.IsString()) { @@ -826,8 +828,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec {{callIndent}}HStringArrayMarshaller.ConvertToUnmanagedUnsafe( {{callIndent}} source: {{callName}}, {{callIndent}} hstringHeaders: (HStringHeader*) _{{localName}}_inlineHeaderArray, - {{callIndent}} hstrings: __{{localName}}_span, - {{callIndent}} pinnedGCHandles: __{{localName}}_pinnedHandleSpan); + {{callIndent}} hstrings: {{names.Span}}, + {{callIndent}} pinnedGCHandles: {{names.PinnedHandleSpan}}); """); } else @@ -1039,6 +1041,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); + ArrayTempNames names = new(localName); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); // Determine the ABI element type for the data pointer parameter. // - Strings / runtime classes / objects: void** @@ -1074,7 +1077,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] {{callIndent}}static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); - {{callIndent}}CopyToManaged_{{localName}}(null, (uint)__{{localName}}_span.Length, {{dataCastType}}_{{localName}}, {{callName}}); + {{callIndent}}CopyToManaged_{{localName}}(null, (uint){{names.Span}}.Length, {{dataCastType}}_{{localName}}, {{callName}}); """); } @@ -1379,6 +1382,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } string localName = p.GetParamLocalName(paramNameOverride); + ArrayTempNames names = new(localName); if (szArr.BaseType.IsString()) { @@ -1389,16 +1393,16 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.PassArray) { writer.WriteLine(isMultiline: true, $$""" - HStringArrayMarshaller.Dispose(__{{localName}}_pinnedHandleSpan); + HStringArrayMarshaller.Dispose({{names.PinnedHandleSpan}}); - if (__{{localName}}_pinnedHandleArrayFromPool is not null) + if ({{names.PinnedHandleArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool.Shared.Return(__{{localName}}_pinnedHandleArrayFromPool); + global::System.Buffers.ArrayPool.Shared.Return({{names.PinnedHandleArrayFromPool}}); } - if (__{{localName}}_headerArrayFromPool is not null) + if ({{names.HeaderArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool.Shared.Return(__{{localName}}_headerArrayFromPool); + global::System.Buffers.ArrayPool.Shared.Return({{names.HeaderArrayFromPool}}); } """); } @@ -1406,9 +1410,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Both PassArray and FillArray need the inline-array's nint pool returned. writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - if (__{{localName}}_arrayFromPool is not null) + if ({{names.ArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool.Shared.Return(__{{localName}}_arrayFromPool); + global::System.Buffers.ArrayPool.Shared.Return({{names.ArrayFromPool}}); } """); } @@ -1444,9 +1448,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.WriteLine(isMultiline: true, $$""" ); - fixed({{fixedPtrType}} _{{localName}} = __{{localName}}_span) + fixed({{fixedPtrType}} _{{localName}} = {{names.Span}}) { - Dispose_{{localName}}(null, (uint) __{{localName}}_span.Length, {{disposeCastType}}_{{localName}}); + Dispose_{{localName}}(null, (uint) {{names.Span}}.Length, {{disposeCastType}}_{{localName}}); } """); } @@ -1460,9 +1464,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec : "nint"; writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - if (__{{localName}}_arrayFromPool is not null) + if ({{names.ArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool<{{poolStorageT}}>.Shared.Return(__{{localName}}_arrayFromPool); + global::System.Buffers.ArrayPool<{{poolStorageT}}>.Shared.Return({{names.ArrayFromPool}}); } """); } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 08ddaf94d..0cf18895d 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -267,30 +267,31 @@ public override unsafe void Invoke( hasNonBlittableArray = true; string raw = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(raw); + ArrayTempNames names = new(raw); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16 __{{raw}}_inlineArray); - nint[] __{{raw}}_arrayFromPool = null; - Span __{{raw}}_span = {{callName}}.Length <= 16 - ? __{{raw}}_inlineArray[..{{callName}}.Length] - : (__{{raw}}_arrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlineArray}}); + nint[] {{names.ArrayFromPool}} = null; + Span {{names.Span}} = {{callName}}.Length <= 16 + ? {{names.InlineArray}}[..{{callName}}.Length] + : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); """); if (szArr.BaseType.IsString()) { writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16 __{{raw}}_inlineHeaderArray); - HStringHeader[] __{{raw}}_headerArrayFromPool = null; - Span __{{raw}}_headerSpan = {{callName}}.Length <= 16 - ? __{{raw}}_inlineHeaderArray[..{{callName}}.Length] - : (__{{raw}}_headerArrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlineHeaderArray}}); + HStringHeader[] {{names.HeaderArrayFromPool}} = null; + Span {{names.HeaderSpan}} = {{callName}}.Length <= 16 + ? {{names.InlineHeaderArray}}[..{{callName}}.Length] + : ({{names.HeaderArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - Unsafe.SkipInit(out InlineArray16 __{{raw}}_inlinePinnedHandleArray); - nint[] __{{raw}}_pinnedHandleArrayFromPool = null; - Span __{{raw}}_pinnedHandleSpan = {{callName}}.Length <= 16 - ? __{{raw}}_inlinePinnedHandleArray[..{{callName}}.Length] - : (__{{raw}}_pinnedHandleArrayFromPool = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlinePinnedHandleArray}}); + nint[] {{names.PinnedHandleArrayFromPool}} = null; + Span {{names.PinnedHandleSpan}} = {{callName}}.Length <= 16 + ? {{names.InlinePinnedHandleArray}}[..{{callName}}.Length] + : ({{names.PinnedHandleArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); """); } } @@ -443,6 +444,7 @@ public override unsafe void Invoke( string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); + ArrayTempNames names = new(raw); if (szArr.BaseType.IsString()) { @@ -450,8 +452,8 @@ public override unsafe void Invoke( {{callIndent}}HStringArrayMarshaller.ConvertToUnmanagedUnsafe( {{callIndent}} source: {{pname}}, {{callIndent}} hstringHeaders: (HStringHeader*) _{{raw}}_inlineHeaderArray, - {{callIndent}} hstrings: __{{raw}}_span, - {{callIndent}} pinnedGCHandles: __{{raw}}_pinnedHandleSpan); + {{callIndent}} hstrings: {{names.Span}}, + {{callIndent}} pinnedGCHandles: {{names.PinnedHandleSpan}}); """); } else @@ -604,21 +606,22 @@ public override unsafe void Invoke( } string raw = p.GetRawName(); + ArrayTempNames names = new(raw); if (szArr.BaseType.IsString()) { writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - HStringArrayMarshaller.Dispose(__{{raw}}_pinnedHandleSpan); + HStringArrayMarshaller.Dispose({{names.PinnedHandleSpan}}); - if (__{{raw}}_pinnedHandleArrayFromPool is not null) + if ({{names.PinnedHandleArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool.Shared.Return(__{{raw}}_pinnedHandleArrayFromPool); + global::System.Buffers.ArrayPool.Shared.Return({{names.PinnedHandleArrayFromPool}}); } - if (__{{raw}}_headerArrayFromPool is not null) + if ({{names.HeaderArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool.Shared.Return(__{{raw}}_headerArrayFromPool); + global::System.Buffers.ArrayPool.Shared.Return({{names.HeaderArrayFromPool}}); } """); } @@ -629,17 +632,17 @@ public override unsafe void Invoke( [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] static extern void Dispose_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, void** data); - fixed(void* _{{raw}} = __{{raw}}_span) + fixed(void* _{{raw}} = {{names.Span}}) { - Dispose_{{raw}}(null, (uint) __{{raw}}_span.Length, (void**)_{{raw}}); + Dispose_{{raw}}(null, (uint) {{names.Span}}.Length, (void**)_{{raw}}); } """); } writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - if (__{{raw}}_arrayFromPool is not null) + if ({{names.ArrayFromPool}} is not null) { - global::System.Buffers.ArrayPool.Shared.Return(__{{raw}}_arrayFromPool); + global::System.Buffers.ArrayPool.Shared.Return({{names.ArrayFromPool}}); } """); } diff --git a/src/WinRT.Projection.Writer/Helpers/ArrayTempNames.cs b/src/WinRT.Projection.Writer/Helpers/ArrayTempNames.cs new file mode 100644 index 000000000..438bdbbd9 --- /dev/null +++ b/src/WinRT.Projection.Writer/Helpers/ArrayTempNames.cs @@ -0,0 +1,41 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.Helpers; + +/// +/// Naming conventions for the array-temporary locals used by inline-array-or-array-pool +/// marshalling stubs (used by DoAbi / RcwCaller / ConstructorFactory). +/// Centralises the __{prefix}_inlineArray / __{prefix}_arrayFromPool / +/// __{prefix}_span name conventions so future churn lands in one place. +/// +/// The parameter/local identifier prefix (e.g. the raw or call name). +internal readonly record struct ArrayTempNames(string Prefix) +{ + /// The local-variable name for the InlineArray16<T> inline buffer. + public string InlineArray => "__" + Prefix + "_inlineArray"; + + /// The local-variable name for the T[] array-pool rental. + public string ArrayFromPool => "__" + Prefix + "_arrayFromPool"; + + /// The local-variable name for the Span<T> view of either backing store. + public string Span => "__" + Prefix + "_span"; + + /// Auxiliary triple used when string-array marshalling needs a parallel HStringHeader[] pool. + public string InlineHeaderArray => "__" + Prefix + "_inlineHeaderArray"; + + /// The companion to . + public string HeaderArrayFromPool => "__" + Prefix + "_headerArrayFromPool"; + + /// The companion to . + public string HeaderSpan => "__" + Prefix + "_headerSpan"; + + /// Auxiliary triple used when string-array marshalling needs a parallel pinned-handle nint[] pool. + public string InlinePinnedHandleArray => "__" + Prefix + "_inlinePinnedHandleArray"; + + /// The companion to . + public string PinnedHandleArrayFromPool => "__" + Prefix + "_pinnedHandleArrayFromPool"; + + /// The companion to . + public string PinnedHandleSpan => "__" + Prefix + "_pinnedHandleSpan"; +} From 5dccab66131accec2598fdebd395d499619ea6f9 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 18:07:32 -0700 Subject: [PATCH 086/171] R7-5: MethodSignatureInfo parameter-iteration helpers Add category-filtering iterators in `Models\MethodSignatureInfoExtensions.cs`: - `EnumerateWithCategory()`: yields `(index, parameter, category)` triples for all parameters - `ParametersByCategory(ParameterCategory category)`: yields `(index, parameter)` pairs whose resolved category matches - `ArrayParameters()`: yields triples whose category is any of the array shapes - `HasParameterOfCategory(category)`: boolean probe Bulk-migrated 17 `cat != X`/`cat != Y` "for-if-continue" preambles to `foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.X))` across `DoAbi.cs` (9 sites) and `RcwCaller.cs` (8 sites). Sites where the index is unused are destructured as `(_, ParameterInfo p)`; those that consume the index keep `(int i, ParameterInfo p)`. Sites NOT migrated: those that combine the category check with type-shape predicates (`IsRuntimeClassOrInterface`, `IsString`, `IsNullableT`) in a single condition -- these are not pure category filters and would lose readability if forced through the helper. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 92 ++++--------------- .../AbiMethodBodyFactory.RcwCaller.cs | 82 ++++------------- .../Models/MethodSignatureInfoExtensions.cs | 84 +++++++++++++++++ 3 files changed, 119 insertions(+), 139 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 5cb6a02b1..ab491fab4 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -81,15 +81,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Hoist [UnsafeAccessor] declarations for Out generic-instance params: // ConvertToUnmanaged_ wraps the projected value into a WindowsRuntimeObjectReferenceValue. // The body's writeback later references these already-declared accessors. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); @@ -111,15 +105,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // ConvertToUnmanaged_ and the return-array ConvertToUnmanaged_ to the // top of the method body, before locals and the try block. The actual call sites later // in the body reference these already-declared accessors. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - if (cat != ParameterCategory.ReceiveArray) - { - continue; - } + { string raw = p.GetRawName(); SzArrayTypeSignature sza = p.Type.AsSzArray()!; @@ -181,29 +169,17 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // NOTE: Ref params (WinRT 'in T' / 'ref const T') are READ-ONLY inputs from the caller's // perspective. Do NOT zero * (it's the input value) and do NOT declare a local // (we read directly via *). - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"*{ptr} = default;"); } - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { string raw = p.GetRawName(); // Use the projected (non-ABI) type for the local variable. @@ -216,15 +192,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // For each ReceiveArray parameter (out T[]), zero the destination + size out pointers // and declare a managed array local. The managed call passes 'out __' and after // the call we copy to the ABI buffer via UnsafeAccessor. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - if (cat != ParameterCategory.ReceiveArray) - { - continue; - } + { string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); @@ -287,15 +257,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // via UnsafeAccessor to convert the native ABI buffer into the managed Span the // delegate sees. For FillArray params, the buffer is fresh storage the user delegate // fills — the post-call writeback loop handles that. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.PassArray)) - if (cat != ParameterCategory.PassArray) - { - continue; - } + { if (p.Type is not SzArrayTypeSignature szArr) { @@ -482,15 +446,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // After call: write back out params to caller's pointer. // NOTE: Ref params (WinRT 'in T') are read-only inputs — never written back. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); @@ -542,15 +500,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // After call: for ReceiveArray params, emit ConvertToUnmanaged_ call (the // [UnsafeAccessor] declaration was hoisted to the top of the method body). - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - if (cat != ParameterCategory.ReceiveArray) - { - continue; - } + { string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); @@ -562,15 +514,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // native ABI buffer.. // which emits 'CopyToUnmanaged_(null, __, __Size, (T*))'. // Blittable element types don't need this — the Span wraps the native buffer directly. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.FillArray)) - if (cat != ParameterCategory.FillArray) - { - continue; - } + { if (p.Type is not SzArrayTypeSignature szFA) { @@ -826,4 +772,4 @@ internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, Proj writer.Write(pname); } } -} +} \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 67b8b2d5c..d035b923f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -360,15 +360,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // Declare locals for Out parameters (need to be passed as &__ to the call). - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); @@ -379,15 +373,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // Declare locals for ReceiveArray params (uint length + element pointer). - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - if (cat != ParameterCategory.ReceiveArray) - { - continue; - } + { string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; @@ -514,16 +502,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // return or Out runtime class params). Input string params no longer need try/finally — // they use the HString fast-path (stack-allocated HStringReference, no free needed). bool hasOutNeedsCleanup = false; - for (int i = 0; i < sig.Parameters.Count; i++) + foreach ((int i, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - - if (cat != ParameterCategory.Out) - { - continue; - } - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); if (uOut.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || uOut.IsSystemType() || context.AbiTypeShapeResolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) @@ -1019,15 +999,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // store it in the user's Span.write_marshal_from_abi // Blittable element types (primitives and almost-blittable structs) don't need this // because the user's Span wraps the same memory the native side wrote to. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.FillArray)) - if (cat != ParameterCategory.FillArray) - { - continue; - } + { if (p.Type is not SzArrayTypeSignature szFA) { @@ -1082,15 +1056,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // After call: write back Out params to caller's 'out' var. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); @@ -1160,15 +1128,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // Writeback for ReceiveArray params: emit a UnsafeAccessor + assign to the out param. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - if (cat != ParameterCategory.ReceiveArray) - { - continue; - } + { string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); @@ -1472,15 +1434,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // 2. Free Out string/object/runtime-class params. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - if (cat != ParameterCategory.Out) - { - continue; - } + { TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); string localName = p.GetParamLocalName(paramNameOverride); @@ -1504,15 +1460,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // 3. Free ReceiveArray params via UnsafeAccessor. - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - if (cat != ParameterCategory.ReceiveArray) - { - continue; - } + { string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; @@ -1609,4 +1559,4 @@ internal static void EmitParamArgConversion(IndentedTextWriter writer, Projectio writer.Write(pname); } } -} +} \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs new file mode 100644 index 000000000..02e4a65c2 --- /dev/null +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs @@ -0,0 +1,84 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System.Collections.Generic; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Category-filtered iteration helpers for . Each +/// iterator pre-computes the for the requested filter and +/// yields the (index, parameter) tuples. The index must remain available because several +/// callers use it to control comma emission or fixed-block nesting. +/// +internal static class MethodSignatureInfoExtensions +{ + extension(MethodSignatureInfo sig) + { + /// + /// Yields each (index, parameter, resolved category) triple for the method's parameters + /// in declaration order. + /// + public IEnumerable<(int Index, ParameterInfo Parameter, ParameterCategory Category)> EnumerateWithCategory() + { + for (int i = 0; i < sig.Parameters.Count; i++) + { + ParameterInfo p = sig.Parameters[i]; + yield return (i, p, ParameterCategoryResolver.GetParamCategory(p)); + } + } + + /// + /// Yields each (index, parameter) pair whose resolved category equals + /// . + /// + public IEnumerable<(int Index, ParameterInfo Parameter)> ParametersByCategory(ParameterCategory category) + { + for (int i = 0; i < sig.Parameters.Count; i++) + { + ParameterInfo p = sig.Parameters[i]; + + if (ParameterCategoryResolver.GetParamCategory(p) == category) + { + yield return (i, p); + } + } + } + + /// + /// Yields each (index, parameter, category) triple whose resolved category is one of + /// the array shapes (, + /// , ). + /// + public IEnumerable<(int Index, ParameterInfo Parameter, ParameterCategory Category)> ArrayParameters() + { + for (int i = 0; i < sig.Parameters.Count; i++) + { + ParameterInfo p = sig.Parameters[i]; + ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + + if (cat.IsAnyArray()) + { + yield return (i, p, cat); + } + } + } + + /// + /// Returns whether any parameter has the given . + /// + public bool HasParameterOfCategory(ParameterCategory category) + { + for (int i = 0; i < sig.Parameters.Count; i++) + { + if (ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]) == category) + { + return true; + } + } + return false; + } + } +} From c242771032c7a589cd8b00445b3d1e98c6be9218 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 18:10:24 -0700 Subject: [PATCH 087/171] R7-3: MethodSignatureMarshallingFacts record Add `MethodSignatureMarshallingFacts` record that bundles all per-method return-shape booleans and per-parameter-shape probes used by the RCW-caller body emitter. Computed once via a single parameter walk in `MethodSignatureMarshallingFacts.From(sig, resolver)` instead of being re-derived inline via 4 separate `for-cat-if-break` probes. Fields: - `ReturnShape`, `ReturnIsString`, `ReturnIsRefType`, `ReturnIsBlittableStruct`, `ReturnIsComplexStruct`, `ReturnIsReceiveArray`, `ReturnIsHResultException`, `ReturnIsSystemTypeForCleanup` - `HasOutNeedsCleanup`, `HasReceiveArray`, `HasNonBlittablePassArray`, `HasComplexStructInput` - Composed `NeedsTryFinally` (the disjunction used to gate try/finally emission) Migrated `EmitAbiMethodBodyIfSimple`: ~60 lines of inline boolean derivation (lines 41-55 + 504-555 of RcwCaller.cs) collapsed to a single `MethodSignatureMarshallingFacts facts = ...From(sig, resolver);` call. Local boolean aliases (returnIsString, etc.) are still declared from the record for back-compat with downstream call sites in the same method body. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AbiMethodBodyFactory.RcwCaller.cs | 76 ++--------- .../Models/MethodSignatureMarshallingFacts.cs | 124 ++++++++++++++++++ 2 files changed, 134 insertions(+), 66 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index d035b923f..49a9e2dcb 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -40,19 +40,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { TypeSignature? rt = sig.ReturnType; - AbiTypeShapeKind returnShape = rt is null ? AbiTypeShapeKind.Unknown : context.AbiTypeShapeResolver.Resolve(rt).Kind; - - bool returnIsString = returnShape == AbiTypeShapeKind.String; - bool returnIsRefType = returnShape.IsReferenceType(); - bool returnIsBlittableStruct = returnShape == AbiTypeShapeKind.BlittableStruct; - bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; - bool returnIsReceiveArray = rt is SzArrayTypeSignature retSzCheck - && (context.AbiTypeShapeResolver.IsBlittableAbiElement(retSzCheck.BaseType) - || retSzCheck.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) - || context.AbiTypeShapeResolver.IsComplexStruct(retSzCheck.BaseType) - || retSzCheck.BaseType.IsHResultException() - || context.AbiTypeShapeResolver.IsMappedAbiValueType(retSzCheck.BaseType)); - bool returnIsHResultException = returnShape == AbiTypeShapeKind.HResultException; + MethodSignatureMarshallingFacts facts = MethodSignatureMarshallingFacts.From(sig, context.AbiTypeShapeResolver); + + bool returnIsString = facts.ReturnIsString; + bool returnIsRefType = facts.ReturnIsRefType; + bool returnIsBlittableStruct = facts.ReturnIsBlittableStruct; + bool returnIsComplexStruct = facts.ReturnIsComplexStruct; + bool returnIsReceiveArray = facts.ReturnIsReceiveArray; + bool returnIsHResultException = facts.ReturnIsHResultException; // Build the function pointer signature: void*, [paramAbiType...,] [retAbiType*,] int StringBuilder fp = new(); @@ -501,58 +496,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Determine if we need a try/finally (for cleanup of string/refType return or receive array // return or Out runtime class params). Input string params no longer need try/finally — // they use the HString fast-path (stack-allocated HStringReference, no free needed). - bool hasOutNeedsCleanup = false; - foreach ((int i, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - { - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - - if (uOut.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) || uOut.IsSystemType() || context.AbiTypeShapeResolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) - { - hasOutNeedsCleanup = true; - break; - } - } - bool hasReceiveArray = false; - for (int i = 0; i < sig.Parameters.Count; i++) - { - if (ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]) == ParameterCategory.ReceiveArray) - { - hasReceiveArray = true; - break; - } - } - bool hasNonBlittablePassArray = false; - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - - if (cat.IsArrayInput() - && p.Type is SzArrayTypeSignature szArrCheck - && !context.AbiTypeShapeResolver.IsBlittableAbiElement(szArrCheck.BaseType) - && !context.AbiTypeShapeResolver.IsMappedAbiValueType(szArrCheck.BaseType)) - { - hasNonBlittablePassArray = true; - break; - } - } - bool hasComplexStructInput = false; - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - - if ((cat is ParameterCategory.In or ParameterCategory.Ref) && context.AbiTypeShapeResolver.IsComplexStruct(AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type))) - { - hasComplexStructInput = true; - break; - } - } - - // System.Type return: ABI.System.Type contains an HSTRING that must be disposed - // after marshalling to managed System.Type, otherwise the HSTRING leaks. - bool returnIsSystemTypeForCleanup = rt is not null && rt.IsSystemType(); - bool needsTryFinally = returnIsString || returnIsRefType || returnIsReceiveArray || hasOutNeedsCleanup || hasReceiveArray || returnIsComplexStruct || hasNonBlittablePassArray || hasComplexStructInput || returnIsSystemTypeForCleanup; + bool needsTryFinally = facts.NeedsTryFinally; if (needsTryFinally) { @@ -1497,7 +1441,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine($" {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.Dispose(__retval);"); } - else if (returnIsSystemTypeForCleanup) + else if (facts.ReturnIsSystemTypeForCleanup) { // System.Type return: dispose the ABI.System.Type's HSTRING fields. writer.WriteLine(" global::ABI.System.TypeMarshaller.Dispose(__retval);"); diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs new file mode 100644 index 000000000..da1b3f499 --- /dev/null +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -0,0 +1,124 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Resolvers; + +namespace WindowsRuntime.ProjectionWriter.Models; + +/// +/// Pre-computed marshalling flags for a used by the +/// RCW-caller and Do_Abi body emitters. Bundles the return-shape classification and the +/// per-parameter-shape probes that drive try/finally emission, so the calling code only +/// needs to walk the parameter list once instead of re-deriving each flag inline. +/// +/// The resolved of the return type, or when the method returns void. +/// True when the return type is . +/// True when the return type's shape is reference-typed (per ). +/// True when the return type is a blittable struct. +/// True when the return type is a complex struct. +/// True when the return type is an SZ-array whose element is a known ABI element shape (blittable, ref-like, complex struct, HResult-exception, or mapped value type). +/// True when the return type is (mapped from WinRT HResult). +/// True when the return type is ; its ABI form holds an HSTRING that must be disposed. +/// True when at least one Out parameter's underlying type carries a resource that requires post-call cleanup (ref-like array element, System.Type, complex struct, or generic instance). +/// True when at least one parameter has ReceiveArray category. +/// True when at least one parameter has Pass/Fill-array category and its element type is neither blittable nor mapped value type. +/// True when at least one In/Ref parameter's underlying type is a complex struct (needs marshaller initialisation). +internal readonly record struct MethodSignatureMarshallingFacts( + AbiTypeShapeKind ReturnShape, + bool ReturnIsString, + bool ReturnIsRefType, + bool ReturnIsBlittableStruct, + bool ReturnIsComplexStruct, + bool ReturnIsReceiveArray, + bool ReturnIsHResultException, + bool ReturnIsSystemTypeForCleanup, + bool HasOutNeedsCleanup, + bool HasReceiveArray, + bool HasNonBlittablePassArray, + bool HasComplexStructInput) +{ + /// + /// True when the emitted RCW-caller body must wrap the vtable call in a try/finally + /// to cover any of the resource-cleanup paths (return-side or parameter-side). + /// + public bool NeedsTryFinally => + ReturnIsString || ReturnIsRefType || ReturnIsReceiveArray || HasOutNeedsCleanup + || HasReceiveArray || ReturnIsComplexStruct || HasNonBlittablePassArray + || HasComplexStructInput || ReturnIsSystemTypeForCleanup; + + /// + /// Computes the marshalling facts for using + /// for shape classification. + /// + public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiTypeShapeResolver resolver) + { + TypeSignature? rt = sig.ReturnType; + AbiTypeShapeKind returnShape = rt is null ? AbiTypeShapeKind.Unknown : resolver.Resolve(rt).Kind; + + bool returnIsString = returnShape == AbiTypeShapeKind.String; + bool returnIsRefType = returnShape.IsReferenceType(); + bool returnIsBlittableStruct = returnShape == AbiTypeShapeKind.BlittableStruct; + bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; + bool returnIsReceiveArray = rt is SzArrayTypeSignature retSz + && (resolver.IsBlittableAbiElement(retSz.BaseType) + || retSz.BaseType.IsAbiArrayElementRefLike(resolver) + || resolver.IsComplexStruct(retSz.BaseType) + || retSz.BaseType.IsHResultException() + || resolver.IsMappedAbiValueType(retSz.BaseType)); + bool returnIsHResultException = returnShape == AbiTypeShapeKind.HResultException; + bool returnIsSystemTypeForCleanup = rt is not null && rt.IsSystemType(); + + bool hasOutNeedsCleanup = false; + bool hasReceiveArray = false; + bool hasNonBlittablePassArray = false; + bool hasComplexStructInput = false; + + foreach ((_, ParameterInfo p, ParameterCategory cat) in sig.EnumerateWithCategory()) + { + if (!hasOutNeedsCleanup && cat == ParameterCategory.Out) + { + TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + + if (uOut.IsAbiArrayElementRefLike(resolver) || uOut.IsSystemType() || resolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) + { + hasOutNeedsCleanup = true; + } + } + + if (!hasReceiveArray && cat == ParameterCategory.ReceiveArray) + { + hasReceiveArray = true; + } + + if (!hasNonBlittablePassArray && cat.IsArrayInput() + && p.Type is SzArrayTypeSignature szArr + && !resolver.IsBlittableAbiElement(szArr.BaseType) + && !resolver.IsMappedAbiValueType(szArr.BaseType)) + { + hasNonBlittablePassArray = true; + } + + if (!hasComplexStructInput && (cat is ParameterCategory.In or ParameterCategory.Ref) + && resolver.IsComplexStruct(AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type))) + { + hasComplexStructInput = true; + } + } + + return new MethodSignatureMarshallingFacts( + ReturnShape: returnShape, + ReturnIsString: returnIsString, + ReturnIsRefType: returnIsRefType, + ReturnIsBlittableStruct: returnIsBlittableStruct, + ReturnIsComplexStruct: returnIsComplexStruct, + ReturnIsReceiveArray: returnIsReceiveArray, + ReturnIsHResultException: returnIsHResultException, + ReturnIsSystemTypeForCleanup: returnIsSystemTypeForCleanup, + HasOutNeedsCleanup: hasOutNeedsCleanup, + HasReceiveArray: hasReceiveArray, + HasNonBlittablePassArray: hasNonBlittablePassArray, + HasComplexStructInput: hasComplexStructInput); + } +} \ No newline at end of file From c1935243aedf0b768d3f61b68e67c9047cb05a1a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Mon, 18 May 2026 18:12:36 -0700 Subject: [PATCH 088/171] R7-12: AbiArrayElementKind classifier + initial migrations Add `AbiArrayElementKind` enum + `AbiTypeShapeResolver.ClassifyArrayElement` discriminator helper for the 6-way pointer-type ladder used by SZ-array parameter / return-type marshalling: - `RefLikeVoidStar` (strings, runtime classes/interfaces, objects) - `HResultException` (System.Exception) - `MappedValueType` (DateTime/TimeSpan/etc.) - `ComplexStruct` - `BlittableStruct` - `BlittablePrimitive` Migrated 2 of the 6+ if-else-if ladder sites to switch-expression form on the new enum: - `AbiMethodBodyFactory.RcwCaller.cs:120-141` (parameter-side ReceiveArray pointer-type append in the function-pointer signature builder) - `AbiMethodBodyFactory.RcwCaller.cs:184-207` (return-side ReceiveArray pointer-type append in the function-pointer signature builder) The remaining sites in DoAbi.cs / RcwCaller.cs / ConstructorFactory.cs have substantial per-site differences in surrounding code (different output shapes: `*data`-suffixed param strings, cast types, etc.) and would require either an over-parameterised emission helper or per-site switch expressions that don't share much logic. Future migrations can land incrementally once the enum / discriminator are available. Validation: 763/763 byte-identical; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AbiMethodBodyFactory.RcwCaller.cs | 60 +++++-------------- .../Models/AbiArrayElementKind.cs | 30 ++++++++++ .../Resolvers/AbiTypeShapeResolver.cs | 39 ++++++++++++ 3 files changed, 85 insertions(+), 44 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 49a9e2dcb..51152838a 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -117,28 +117,15 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature sza = p.Type.AsSzArray()!; _ = fp.Append(", uint*, "); - if (sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) + _ = fp.Append(context.AbiTypeShapeResolver.ClassifyArrayElement(sza.BaseType) switch { - _ = fp.Append("void*"); - } - else if (sza.BaseType.IsHResultException()) - { - _ = fp.Append(WellKnownAbiTypeNames.AbiSystemException); - } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(sza.BaseType)) - { - _ = fp.Append(AbiTypeHelpers.GetMappedAbiTypeName(sza.BaseType)); - } - else if (context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType)) - { - _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType)); - } - else - { - _ = fp.Append(context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType)); - } + AbiArrayElementKind.RefLikeVoidStar => "void*", + AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, + AbiArrayElementKind.MappedValueType => AbiTypeHelpers.GetMappedAbiTypeName(sza.BaseType), + AbiArrayElementKind.ComplexStruct => AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType), + AbiArrayElementKind.BlittableStruct => AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType), + _ => AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType), + }); _ = fp.Append("**"); continue; @@ -181,30 +168,15 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; _ = fp.Append(", uint*, "); - if (retSz.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) + _ = fp.Append(context.AbiTypeShapeResolver.ClassifyArrayElement(retSz.BaseType) switch { - _ = fp.Append("void*"); - } - else if (context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType)) - { - _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType)); - } - else if (retSz.BaseType.IsHResultException()) - { - _ = fp.Append(WellKnownAbiTypeNames.AbiSystemException); - } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType)) - { - _ = fp.Append(AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType)); - } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType)) - { - _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType)); - } - else - { - _ = fp.Append(AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType)); - } + AbiArrayElementKind.RefLikeVoidStar => "void*", + AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, + AbiArrayElementKind.MappedValueType => AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType), + AbiArrayElementKind.ComplexStruct => AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType), + AbiArrayElementKind.BlittableStruct => AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType), + _ => AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType), + }); _ = fp.Append("**"); } diff --git a/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs b/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs new file mode 100644 index 000000000..745eb5905 --- /dev/null +++ b/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs @@ -0,0 +1,30 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.Models; + +/// +/// Classification of an SZ-array element's ABI marshalling shape. Used by the per-array-element +/// pointer-type ladder in RcwCaller / DoAbi bodies so callers can dispatch via +/// switch instead of an if-else-if chain. +/// +internal enum AbiArrayElementKind +{ + /// The element flows as a void* at the ABI (strings, runtime classes/interfaces, objects). + RefLikeVoidStar, + + /// The element is (mapped from WinRT HResult). + HResultException, + + /// The element is a mapped value type (e.g. WinRT DateTime -> ). + MappedValueType, + + /// The element is a complex struct (has reference-typed fields that require per-field marshalling). + ComplexStruct, + + /// The element is a blittable struct (all fields are primitives or blittable structs). + BlittableStruct, + + /// The element is a blittable primitive (, , etc.). + BlittablePrimitive, +} \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs index 15d50fa2b..5ec814800 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs @@ -111,6 +111,45 @@ public bool IsMappedAbiValueType(TypeSignature signature) public bool IsBlittableAbiElement(TypeSignature signature) => IsBlittablePrimitive(signature) || IsBlittableStruct(signature); + /// + /// Classifies into one of the six + /// values used by the per-element pointer-type ladders. + /// This is the discriminator-only form -- callers translate the kind into the per-site + /// emission output. + /// + /// The SZ-array element type to classify. + /// The classification kind. + /// is the default for shapes that don't match any of the other branches. + public AbiArrayElementKind ClassifyArrayElement(TypeSignature elementType) + { + if (elementType.IsAbiArrayElementRefLike(this)) + { + return AbiArrayElementKind.RefLikeVoidStar; + } + + if (elementType.IsHResultException()) + { + return AbiArrayElementKind.HResultException; + } + + if (IsMappedAbiValueType(elementType)) + { + return AbiArrayElementKind.MappedValueType; + } + + if (IsComplexStruct(elementType)) + { + return AbiArrayElementKind.ComplexStruct; + } + + if (IsBlittableStruct(elementType)) + { + return AbiArrayElementKind.BlittableStruct; + } + + return AbiArrayElementKind.BlittablePrimitive; + } + /// /// Inner classification routine. Returns the resolved for /// ; returns when the From 5e3d379e31afe5d4f2cd6d18f24574db814fc4dc Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 10:30:59 -0700 Subject: [PATCH 089/171] Refactor extension methods' docs & parameter names Rename extension parameter 'cat' to 'category' in ParameterCategoryExtensions, add an XML comment, and expand expression-bodied IsArrayInput/IsAnyArray members into block bodies for readability. Update XML documentation in TypeSignatureExtensions to prefer cref-style references for primitives and projected types, adjust the AbiTypeShapeResolver reference, and clarify several doc comments (nullable, System.Type, HResult/Exception, etc.). These are non-functional documentation and style improvements across the two extension files. --- .../Extensions/ParameterCategoryExtensions.cs | 17 +++++++++------- .../Extensions/TypeSignatureExtensions.cs | 20 +++++++++---------- 2 files changed, 20 insertions(+), 17 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs index 7f85acb0d..67eb04585 100644 --- a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs @@ -10,23 +10,26 @@ namespace WindowsRuntime.ProjectionWriter; /// internal static class ParameterCategoryExtensions { - extension(ParameterCategory cat) + /// The input parameter category. + extension(ParameterCategory category) { /// - /// Returns whether is an input-side array category + /// Returns whether the input category is an input-side array category /// ( or ). /// public bool IsArrayInput() - => cat is ParameterCategory.PassArray or ParameterCategory.FillArray; + { + return category is ParameterCategory.PassArray or ParameterCategory.FillArray; + } /// - /// Returns whether is any of the array-shaped categories + /// Returns whether the input category is any of the array-shaped categories /// (, , /// or ). /// public bool IsAnyArray() - => cat is ParameterCategory.PassArray - or ParameterCategory.FillArray - or ParameterCategory.ReceiveArray; + { + return category is ParameterCategory.PassArray or ParameterCategory.FillArray or ParameterCategory.ReceiveArray; + } } } diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 2bf60e154..251ddaeeb 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -16,7 +16,7 @@ namespace WindowsRuntime.ProjectionWriter; /// /// Predicates that need cross-module type resolution (e.g. IsBlittablePrimitive /// with cross-module enum lookup, IsAnyStruct, IsComplexStruct) live in -/// and the ; +/// and the ; /// they are intentionally not included here. /// internal static class TypeSignatureExtensions @@ -24,9 +24,9 @@ internal static class TypeSignatureExtensions extension(TypeSignature sig) { /// - /// Returns whether the signature is the corlib primitive. + /// Returns whether the signature is the corlib primitive. /// - /// if the signature is System.String; otherwise . + /// if the signature is ; otherwise . public bool IsString() { return sig is CorLibTypeSignature corlib && corlib.ElementType == ElementType.String; @@ -35,7 +35,7 @@ public bool IsString() /// /// Returns whether the signature is the corlib primitive. /// - /// if the signature is System.Object; otherwise . + /// if the signature is ; otherwise . public bool IsObject() { return sig is CorLibTypeSignature corlib && corlib.ElementType == ElementType.Object; @@ -46,7 +46,7 @@ public bool IsObject() /// that resolves to it, including the WinRT Windows.UI.Xaml.Interop.TypeName struct /// that is mapped to it). /// - /// if the signature is the projected System.Type; otherwise . + /// if the signature is the projected ; otherwise . public bool IsSystemType() { if (sig is TypeDefOrRefSignature td && td.Type is { } t) @@ -69,7 +69,7 @@ public bool IsSystemType() /// /// Returns whether the signature is a WinRT IReference<T> or a - /// instantiation (both project to Nullable<T> in C#). + /// instantiation (both project to in C#). /// /// if the signature is a Nullable-shaped generic instantiation; otherwise . public bool IsNullableT() @@ -88,7 +88,7 @@ public bool IsNullableT() /// /// Returns the single type argument of a generic instance type signature, or /// if the signature is not a single-arg generic instance. Used to peel the inner T from - /// Nullable<T> / IReference<T>. + /// / IReference<T>. /// /// The inner type argument, or . public TypeSignature? GetNullableInnerType() @@ -112,11 +112,11 @@ public bool IsGenericInstance() } /// - /// Returns whether the signature is the special System.Exception / + /// Returns whether the signature is the special / /// Windows.Foundation.HResult pair (which uses an HResult struct as its ABI form /// and requires custom marshalling via ABI.System.ExceptionMarshaller). /// - /// if the signature is the projected HResult/Exception; otherwise . + /// if the signature is the projected HResult/; otherwise . public bool IsHResultException() { if (sig is not TypeDefOrRefSignature td || td.Type is null) @@ -213,7 +213,7 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) } /// - /// Strips byref + custom modifiers from and returns the result + /// Strips byref + custom modifiers from the input signature and returns the result /// as an if the underlying type is one; otherwise /// returns . /// From 010ea42ca73231bcfe77f938b524f1317858a45a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 10:31:11 -0700 Subject: [PATCH 090/171] Refactor extensions and remove event helper Remove EventDefinitionExtensions and simplify related extension usage; update various extension helpers and small formatter fixes. - Deleted EventDefinitionExtensions.cs and updated call sites to use evt.AddMethod directly (AbiMethodBodyFactory.MethodsClass.cs). - IHasCustomAttributeExtensions: use WellKnownNamespaces helper, use attribute.Type.IsTypeOf for matching, rename loop variable for clarity, and expand small expression-bodied members to blocks for readability. - CustomAttributeExtensions: minor formatting/spacing improvements, clarified comment punctuation, and kept existing uint->int coercion handling. - AbiTypeShapeKindExtensions: change IsReferenceType to an explicit block-style return and clarified XML comment wording. - IndentedTextWriterExtensions: minor whitespace tweaks around iteration. These changes are mostly refactors and readability/clarity improvements without behavioral changes. --- .../Extensions/AbiTypeShapeKindExtensions.cs | 7 ++++-- .../Extensions/CustomAttributeExtensions.cs | 8 ++++-- .../Extensions/EventDefinitionExtensions.cs | 22 ---------------- .../IHasCustomAttributeExtensions.cs | 25 +++++++++++-------- .../IndentedTextWriterExtensions.cs | 2 ++ .../AbiMethodBodyFactory.MethodsClass.cs | 2 +- 6 files changed, 28 insertions(+), 38 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs b/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs index 83aca376f..8c8d668d6 100644 --- a/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs @@ -10,18 +10,21 @@ namespace WindowsRuntime.ProjectionWriter; /// internal static class AbiTypeShapeKindExtensions { + /// The input ABI type kind. extension(AbiTypeShapeKind kind) { /// - /// Returns whether the shape is a reference-type marshalling kind: WinRT runtime classes/interfaces, + /// Returns whether the shape is a reference-type marshalling kind: Windows Runtime classes/interfaces, /// delegates, generic instantiations, the corlib primitive, or /// /IReference<T> instantiations. /// public bool IsReferenceType() - => kind is AbiTypeShapeKind.RuntimeClassOrInterface + { + return kind is AbiTypeShapeKind.RuntimeClassOrInterface or AbiTypeShapeKind.Delegate or AbiTypeShapeKind.Object or AbiTypeShapeKind.GenericInstance or AbiTypeShapeKind.NullableT; + } } } diff --git a/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs b/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs index 6b2eb5c40..482b6b4f7 100644 --- a/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/CustomAttributeExtensions.cs @@ -30,6 +30,7 @@ public bool TryGetFixedArgument(int index, [NotNullWhen(true)] out T? value) if (attr.Signature is null || index < 0 || index >= attr.Signature.FixedArguments.Count) { value = default; + return false; } @@ -38,18 +39,21 @@ public bool TryGetFixedArgument(int index, [NotNullWhen(true)] out T? value) if (element is T t) { value = t; + return true; } - // Standard coercion: uint -> int (WinMD often stores numeric metadata values as uint - // in the fixed-args list, but most call sites consume them as int). + // Standard coercion: 'uint' -> 'int' (WinMD often stores numeric metadata values as 'uint' + // in the fixed-args list, but most call sites consume them as 'int'). if (typeof(T) == typeof(int) && element is uint u) { value = (T)(object)(int)u; + return true; } value = default; + return false; } } diff --git a/src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs deleted file mode 100644 index 45fe02a10..000000000 --- a/src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using AsmResolver.DotNet; - -namespace WindowsRuntime.ProjectionWriter; - -/// -/// Extension methods for . -/// -internal static class EventDefinitionExtensions -{ - extension(EventDefinition evt) - { - /// - /// Returns the (add, remove) accessor pair of the event. - /// - /// A tuple of (Add, Remove) accessor methods, either of which may be . - public (MethodDefinition? Add, MethodDefinition? Remove) GetEventMethods() - => (evt.AddMethod, evt.RemoveMethod); - } -} \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs b/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs index 0c4f95371..b8e502e6a 100644 --- a/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.References; namespace WindowsRuntime.ProjectionWriter; @@ -21,15 +22,14 @@ internal static class IHasCustomAttributeExtensions /// if a matching custom attribute is found; otherwise . public bool HasAttribute(string ns, string name) { - foreach (CustomAttribute attr in member.CustomAttributes) + foreach (CustomAttribute attribute in member.CustomAttributes) { - if (attr.Constructor?.DeclaringType is { } dt && - (dt.Namespace?.Value == ns) && - (dt.Name?.Value == name)) + if (attribute.Type?.IsTypeOf(ns, name) is true) { return true; } } + return false; } @@ -42,15 +42,14 @@ public bool HasAttribute(string ns, string name) /// The matching custom attribute, or if none is found. public CustomAttribute? GetAttribute(string ns, string name) { - foreach (CustomAttribute attr in member.CustomAttributes) + foreach (CustomAttribute attribute in member.CustomAttributes) { - if (attr.Constructor?.DeclaringType is { } dt && - (dt.Namespace?.Value == ns) && - (dt.Name?.Value == name)) + if (attribute.Type?.IsTypeOf(ns, name) is true) { - return attr; + return attribute; } } + return null; } @@ -60,7 +59,9 @@ public bool HasAttribute(string ns, string name) /// /// The unqualified name of the Windows.Foundation.Metadata attribute. public bool HasWindowsFoundationMetadataAttribute(string name) - => member.HasAttribute(References.WellKnownNamespaces.WindowsFoundationMetadata, name); + { + return member.HasAttribute(WellKnownNamespaces.WindowsFoundationMetadata, name); + } /// /// Convenience for GetAttribute(ns, name) with the namespace fixed to @@ -68,6 +69,8 @@ public bool HasWindowsFoundationMetadataAttribute(string name) /// /// The unqualified name of the Windows.Foundation.Metadata attribute. public CustomAttribute? GetWindowsFoundationMetadataAttribute(string name) - => member.GetAttribute(References.WellKnownNamespaces.WindowsFoundationMetadata, name); + { + return member.GetAttribute(WellKnownNamespaces.WindowsFoundationMetadata, name); + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs b/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs index 9742e3ac4..a9e04f206 100644 --- a/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs @@ -28,11 +28,13 @@ internal static class IndentedTextWriterExtensions public void WriteSeparated(IEnumerable items, string separator, Action writeItem) { bool first = true; + foreach (T item in items) { writer.WriteIf(!first, separator); writeItem(writer, item); + first = false; } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 1387e317d..308d4b24b 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -114,7 +114,7 @@ public static unsafe bool isGenericEvent = evtSig is GenericInstanceTypeSignature; // Use the add method's WinMD slot (events project as the add_X method's vmethod_index). - (MethodDefinition? addMethod, MethodDefinition? _) = evt.GetEventMethods(); + MethodDefinition? addMethod = evt.AddMethod; int eventSlot = addMethod is not null && methodSlot.TryGetValue(addMethod, out int es) ? es : 0; // Build the projected event source type name. For non-generic delegate handlers, the From 604e37009fe254e276af9d4e1236b64daddd1d34 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 10:31:26 -0700 Subject: [PATCH 091/171] Remove IndentedTextWriterExtensions.cs Delete the IndentedTextWriterExtensions.cs file which contained internal helper extension methods for IndentedTextWriter used by the projection writer (WriteSeparated, WriteCommaSeparated, WriteGlobal, WriteGlobalAbi, WriteAccessibility, WriteAttribute, WriteWellKnownIIDFieldRef). This removes the obsolete/relocated utilities as part of a cleanup/refactor of the projection writer codebase. --- .../IndentedTextWriterExtensions.cs | 117 ------------------ 1 file changed, 117 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs b/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs deleted file mode 100644 index a9e04f206..000000000 --- a/src/WinRT.Projection.Writer/Extensions/IndentedTextWriterExtensions.cs +++ /dev/null @@ -1,117 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using System; -using System.Collections.Generic; -using WindowsRuntime.ProjectionWriter.Generation; -using WindowsRuntime.ProjectionWriter.Writers; -using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; - -namespace WindowsRuntime.ProjectionWriter; - -/// -/// General-purpose extension methods for that capture -/// repeated emission micro-patterns (separator lists, well-known prefixes, etc.). -/// -internal static class IndentedTextWriterExtensions -{ - extension(IndentedTextWriter writer) - { - /// - /// Writes each item in via , with - /// emitted between consecutive items. - /// - /// The item type. - /// The items to write. - /// The separator string emitted between consecutive items (e.g. ", "). - /// A callback that emits a single item. - public void WriteSeparated(IEnumerable items, string separator, Action writeItem) - { - bool first = true; - - foreach (T item in items) - { - writer.WriteIf(!first, separator); - - writeItem(writer, item); - - first = false; - } - } - - /// - /// Writes each item in via , with - /// ", " emitted between consecutive items. - /// - /// The item type. - /// The items to write. - /// A callback that emits a single item. - public void WriteCommaSeparated(IEnumerable items, Action writeItem) - { - writer.WriteSeparated(items, ", ", writeItem); - } - - /// - /// Writes the C# global namespace prefix () followed by - /// . Convenience wrapper for the common - /// writer.Write(GlobalPrefix); writer.Write(typeName); pattern. - /// - /// The fully-qualified type name to emit after the global:: prefix. - public void WriteGlobal(string typeName) - { - writer.Write($"{GlobalPrefix}{typeName}"); - } - - /// - /// Writes the fully-qualified ABI namespace prefix () followed - /// by . Convenience wrapper for the common - /// writer.Write(GlobalAbiPrefix); writer.Write(typeName); pattern. - /// - /// The dot-qualified type name to emit after the global::ABI. prefix. - public void WriteGlobalAbi(string typeName) - { - writer.Write($"{GlobalAbiPrefix}{typeName}"); - } - - /// - /// Writes the projection-wide accessibility modifier ("internal" when - /// or is set; otherwise - /// "public") for an emitted top-level type. - /// - /// The active projection settings. - public void WriteAccessibility(Settings settings) - { - writer.Write(settings.InternalAccessibility); - } - - /// - /// Writes a single C# attribute application of the form [name(args)] on its own - /// line. When is or empty, the parenthesis - /// list is omitted. - /// - /// The unqualified attribute name (without the trailing Attribute suffix). - /// The argument list to render between parentheses, or for no arguments. - public void WriteAttribute(string name, string? args = null) - { - if (string.IsNullOrEmpty(args)) - { - writer.WriteLine($"[{name}]"); - } - else - { - writer.WriteLine($"[{name}({args})]"); - } - } - - /// - /// Writes a fully-qualified reference to a well-known interface IID field - /// (global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_). - /// - /// The bare interface name (e.g. "IInspectable"). - public void WriteWellKnownIIDFieldRef(string interfaceName) - { - writer.Write($"global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_{interfaceName}"); - } - } -} - From dce660b68b1ed9b62829ddeb644f78df6e120bdd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 10:41:18 -0700 Subject: [PATCH 092/171] Refactor method/property helpers and simplify patterns Replace several boolean helper methods with read-only properties (IsConstructor/IsSpecial/IsGetter/IsSetter/IsAdder/IsRemover/IsParameterless/IsDefaultConstructor/IsNoExcept/GetRawName) and update all call sites accordingly. Simplify pattern matching for TypeSpecification generic instances and streamline interface implementation resolution/early returns. Minor whitespace and control-flow cleanups in factories and helpers to improve readability and consistency across the projection writer codebase. --- .../Extensions/ITypeDefOrRefExtensions.cs | 7 ++- .../InterfaceImplementationExtensions.cs | 10 +++- .../Extensions/MethodDefinitionExtensions.cs | 57 +++++++------------ .../Extensions/TypeDefinitionExtensions.cs | 4 +- .../Factories/AbiDelegateFactory.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 8 +-- .../AbiMethodBodyFactory.MethodsClass.cs | 2 +- .../ConstructorFactory.AttributedTypes.cs | 6 +- .../ConstructorFactory.Composable.cs | 6 +- .../Helpers/AbiTypeHelpers.cs | 2 +- 10 files changed, 48 insertions(+), 56 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index e20993663..c9c2d5b76 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -61,15 +61,15 @@ internal static class ITypeDefOrRefExtensions return td; } - if (type is TypeSpecification ts && ts.Signature is GenericInstanceTypeSignature gi) + if (type is TypeSpecification { Signature: GenericInstanceTypeSignature gi }) { - ITypeDefOrRef? gen = gi.GenericType; - return gen?.ResolveAsTypeDefinition(cache); + return gi.GenericType.ResolveAsTypeDefinition(cache); } if (type is TypeReference tr) { (string ns, string nm) = tr.Names(); + return cache.Find(ns, nm); } @@ -96,6 +96,7 @@ public bool MatchesName(string ns, string name) public bool TryGetGenericInstance([NotNullWhen(true)] out GenericInstanceTypeSignature? genericInstance) { genericInstance = (type as TypeSpecification)?.Signature as GenericInstanceTypeSignature; + return genericInstance is not null; } } diff --git a/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs b/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs index efb57e750..16136f1da 100644 --- a/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/InterfaceImplementationExtensions.cs @@ -21,7 +21,9 @@ internal static class InterfaceImplementationExtensions /// /// if the interface is the default interface; otherwise . public bool IsDefaultInterface() - => impl.HasWindowsFoundationMetadataAttribute(DefaultAttribute); + { + return impl.HasWindowsFoundationMetadataAttribute(DefaultAttribute); + } /// /// Returns whether the implemented interface is marked [Overridable] (i.e. derived @@ -29,7 +31,9 @@ public bool IsDefaultInterface() /// /// if the interface is overridable; otherwise . public bool IsOverridable() - => impl.HasWindowsFoundationMetadataAttribute(OverridableAttribute); + { + return impl.HasWindowsFoundationMetadataAttribute(OverridableAttribute); + } /// /// Attempts to resolve the implemented interface to a , handling @@ -48,10 +52,12 @@ public bool TryResolveTypeDef(MetadataCache cache, [NotNullWhen(true)] out TypeD if (impl.Interface is null) { definition = null; + return false; } definition = impl.Interface.ResolveAsTypeDefinition(cache); + return definition is not null; } } diff --git a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs index acba8a4cb..95bbc90eb 100644 --- a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs @@ -18,65 +18,52 @@ internal static class MethodDefinitionExtensions /// Returns whether the method is an instance constructor (i.e. its name is /// .ctor and it is marked as runtime-special). /// - /// if the method is an instance constructor; otherwise . - public bool IsConstructor() - => method.IsRuntimeSpecialName && method.Name == ".ctor"; + public bool IsConstructor => method.IsRuntimeSpecialName && method.Name == ".ctor"; /// /// Returns whether the method is special (has either SpecialName or /// RuntimeSpecialName set in its method attributes -- e.g. property accessors, /// event accessors, constructors). /// - /// if the method is marked special; otherwise . - public bool IsSpecial() - => method.IsSpecialName || method.IsRuntimeSpecialName; - - /// - /// Returns whether the method is the special remove_xxx event remover overload. - /// - /// if the method is an event remover; otherwise . - public bool IsRemoveOverload() - => method.IsSpecialName && (method.Name?.Value?.StartsWith("remove_", StringComparison.Ordinal) == true); + public bool IsSpecial => method.IsSpecialName || method.IsRuntimeSpecialName; /// /// Returns whether the method is a property getter (special method whose name starts with get_). /// - /// if the method is a property getter; otherwise . - public bool IsGetter() - => method.IsSpecialName && (method.Name?.Value?.StartsWith("get_", StringComparison.Ordinal) == true); + public bool IsGetter => method.IsSpecialName && (method.Name?.Value?.StartsWith("get_", StringComparison.Ordinal) == true); /// /// Returns whether the method is a property setter (special method whose name starts with put_). /// - /// if the method is a property setter; otherwise . - public bool IsSetter() - => method.IsSpecialName && (method.Name?.Value?.StartsWith("put_", StringComparison.Ordinal) == true); + public bool IsSetter => method.IsSpecialName && (method.Name?.Value?.StartsWith("put_", StringComparison.Ordinal) == true); /// /// Returns whether the method is an event adder (special method whose name starts with add_). /// - /// if the method is an event adder; otherwise . - public bool IsAdder() - => method.IsSpecialName && (method.Name?.Value?.StartsWith("add_", StringComparison.Ordinal) == true); + public bool IsAdder => method.IsSpecialName && (method.Name?.Value?.StartsWith("add_", StringComparison.Ordinal) == true); /// - /// Returns whether the method is an event remover (alias for ). + /// Returns whether the method is the special remove_xxx event remover overload. /// - /// if the method is an event remover; otherwise . - public bool IsRemover() => method.IsRemoveOverload(); + public bool IsRemover => method.IsSpecialName && (method.Name?.Value?.StartsWith("remove_", StringComparison.Ordinal) == true); /// /// Returns whether the method declares no parameters. /// - public bool IsParameterless() - => method.Parameters.Count == 0; + public bool IsParameterless => method.Parameters.Count == 0; /// /// Returns whether the method is a parameterless instance constructor (i.e. a default /// constructor): runtime-special, name .ctor, no parameters. /// - public bool IsDefaultConstructor() - => method.IsConstructor() && method.IsParameterless(); + public bool IsDefaultConstructor => method.IsConstructor && method.IsParameterless; + + /// + /// Returns whether the method carries the [NoExceptionAttribute] or is an + /// event remover (event removers are implicitly no-throw). + /// + /// if the method is documented to never throw; otherwise . + public bool IsNoExcept => method.IsRemover || method.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); /// /// Returns the method's raw metadata name, falling back to when @@ -84,14 +71,8 @@ public bool IsDefaultConstructor() /// method.Name?.Value ?? string.Empty pattern that appears at many sites. /// public string GetRawName() - => method.Name?.Value ?? string.Empty; - - /// - /// Returns whether the method carries the [NoExceptionAttribute] or is a - /// (event removers are implicitly no-throw). - /// - /// if the method is documented to never throw; otherwise . - public bool IsNoExcept() - => method.IsRemoveOverload() || method.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); + { + return method.Name?.Value ?? string.Empty; + } } } diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index cf195f482..2e6f27e1e 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -23,7 +23,7 @@ public IEnumerable GetNonSpecialMethods() { foreach (MethodDefinition method in type.Methods) { - if (!method.IsSpecial()) + if (!method.IsSpecial) { yield return method; } @@ -117,7 +117,7 @@ public bool HasDefaultConstructor() { foreach (MethodDefinition m in type.Methods) { - if (m.IsDefaultConstructor()) + if (m.IsDefaultConstructor) { return true; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index face3a7f2..90c7e00b0 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -173,7 +173,7 @@ public static unsafe // (after QI/AddRef/Release). Functionally equivalent to the truth's // 'var abiInvoke = ((Vftbl*)*(void***)ThisPtr)->Invoke;' form, just routed // through the slot-indexed dispatch shared with interface CCW callers. - AbiMethodBodyFactory.EmitAbiMethodBodyIfSimple(writer, context, sig, slot: 3, isNoExcept: invoke.IsNoExcept()); + AbiMethodBodyFactory.EmitAbiMethodBodyIfSimple(writer, context, sig, slot: 3, isNoExcept: invoke.IsNoExcept); writer.WriteLine("}"); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index ab491fab4..36326bafe 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -37,10 +37,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection bool returnIsGenericInstance = rt is not null && rt.IsGenericInstance(); bool returnIsBlittableStruct = rt is not null && context.AbiTypeShapeResolver.IsBlittableStruct(rt); - bool isGetter = sig.Method.IsGetter(); - bool isSetter = sig.Method.IsSetter(); - bool isAddEvent = sig.Method.IsAdder(); - bool isRemoveEvent = sig.Method.IsRemover(); + bool isGetter = sig.Method.IsGetter; + bool isSetter = sig.Method.IsSetter; + bool isAddEvent = sig.Method.IsAdder; + bool isRemoveEvent = sig.Method.IsRemover; if (isAddEvent || isRemoveEvent) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 308d4b24b..b5a27cb33 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -64,7 +64,7 @@ public static unsafe writer.Write($"{ret} {mname}(WindowsRuntimeObjectReference thisReference{comma}{parms})"); // Emit the body if we can handle this case. Slot comes from the method's WinMD index. - EmitAbiMethodBodyIfSimple(writer, context, sig, methodSlot[method], isNoExcept: method.IsNoExcept()); + EmitAbiMethodBodyIfSimple(writer, context, sig, methodSlot[method], isNoExcept: method.IsNoExcept); } // Emit property accessors. Each getter / setter consumes one vtable slot — looked up from the underlying method. diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 26effa990..1214a7c71 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -108,9 +108,11 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio int methodIndex = 0; foreach (MethodDefinition method in factoryType.Methods) { - if (method.IsSpecial()) + if (method.IsSpecial) { - methodIndex++; continue; + methodIndex++; + + continue; } MethodSignatureInfo sig = new(method); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 22ccd9619..1642deeb1 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -49,9 +49,11 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec int methodIndex = 0; foreach (MethodDefinition method in composableType.Methods) { - if (method.IsSpecial()) + if (method.IsSpecial) { - methodIndex++; continue; + methodIndex++; + + continue; } // Composable factory methods have signature like: diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 27fedd87a..51fea2909 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -291,7 +291,7 @@ internal static bool HasEmittableMembers(TypeDefinition iface, bool skipExclusiv { foreach (MethodDefinition m in iface.Methods) { - if (!m.IsSpecial()) + if (!m.IsSpecial) { return true; } From 4cf492562da397fad82e891a5238c3b17c5562ad Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:08:27 -0700 Subject: [PATCH 093/171] Refactor type/name helpers and accessors Introduce centralized ITypeDescriptor.Names extension and consolidate duplicate name/matching helpers. Add MethodDefinition.IsInvoke and TypeSignature.IsHResultException, simplify several TypeSignature/TypeDefinition extension implementations with pattern matching and iterators. Rename PropertyDefinition.GetPropertyMethods to GetMethods and change IsNoExcept to a property; update all call sites across factories and emitters to use the new APIs. Miscellaneous formatting/namespace emission tweaks in ProjectionWriterExtensions. These changes reduce duplication, modernize patterns, and streamline property accessor handling. --- .../Extensions/ITypeDefOrRefExtensions.cs | 22 ------- .../Extensions/ITypeDescriptorExtensions.cs | 26 ++++++++ .../Extensions/MethodDefinitionExtensions.cs | 5 ++ .../Extensions/ProjectionWriterExtensions.cs | 5 ++ .../PropertyDefinitionExtensions.cs | 6 +- .../Extensions/TypeDefinitionExtensions.cs | 37 +++++------ .../Extensions/TypeSignatureExtensions.cs | 61 ++++++++----------- .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiInterfaceIDicFactory.cs | 4 +- .../AbiMethodBodyFactory.MethodsClass.cs | 17 ++---- .../Factories/ClassFactory.cs | 4 +- ...assMembersFactory.WriteInterfaceMembers.cs | 2 +- .../Factories/ComponentFactory.cs | 2 +- .../Factories/InterfaceFactory.cs | 2 +- 14 files changed, 90 insertions(+), 105 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index c9c2d5b76..de85eee75 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -15,17 +15,6 @@ internal static class ITypeDefOrRefExtensions { extension(ITypeDefOrRef type) { - /// - /// Returns the namespace and name of the type as a tuple, with both fields - /// guaranteed to be non-: a missing namespace becomes - /// and a missing name becomes . - /// - /// A tuple of (namespace, name) with both fields non-. - public (string Namespace, string Name) Names() - { - return (type.Namespace?.Value ?? string.Empty, type.Name?.Value ?? string.Empty); - } - /// /// Attempts to resolve against , returning /// when the type cannot be resolved (missing assembly, invalid reference, @@ -76,17 +65,6 @@ internal static class ITypeDefOrRefExtensions return null; } - /// - /// Returns whether 's namespace and name match - /// (, ). - /// - /// The expected namespace. - /// The expected unqualified type name. - public bool MatchesName(string ns, string name) - { - return type.Namespace?.Value == ns && type.Name?.Value == name; - } - /// /// Attempts to extract the from /// when it is a whose signature diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs new file mode 100644 index 000000000..7295589a9 --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs @@ -0,0 +1,26 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class ITypeDescriptorExtensions +{ + extension(ITypeDescriptor type) + { + /// + /// Returns the namespace and name of the type as a tuple, with both fields + /// guaranteed to be non-: a missing namespace becomes + /// and a missing name becomes . + /// + /// A tuple of (namespace, name) with both fields non-. + public (string Namespace, string Name) Names() + { + return (type.Namespace ?? string.Empty, type.Name ?? string.Empty); + } + } +} \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs index 95bbc90eb..5e0b67321 100644 --- a/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/MethodDefinitionExtensions.cs @@ -65,6 +65,11 @@ internal static class MethodDefinitionExtensions /// if the method is documented to never throw; otherwise . public bool IsNoExcept => method.IsRemover || method.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); + /// + /// Returns whether the method is the special Invoke method (used for delegates). + /// + public bool IsInvoke => method.IsSpecialName && method.Name is { } name && name.AsSpan().SequenceEqual("Invoke"u8); + /// /// Returns the method's raw metadata name, falling back to when /// the metadata name is . Convenience for the diff --git a/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs index ffb367fa9..a5875bd93 100644 --- a/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ProjectionWriterExtensions.cs @@ -65,12 +65,14 @@ public void WriteFileHeader(ProjectionEmitContext context) public void WriteBeginProjectedNamespace(ProjectionEmitContext context) { string nsPrefix = context.Settings.Component ? "ABI.Impl." : string.Empty; + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" namespace {{nsPrefix}}{{context.CurrentNamespace}} { """); writer.IncreaseIndent(); + if (context.Settings.Component) { context.InAbiImplNamespace = true; @@ -86,6 +88,7 @@ public void WriteEndProjectedNamespace(ProjectionEmitContext context) { writer.DecreaseIndent(); writer.WriteLine("}"); + context.InAbiImplNamespace = false; } @@ -103,6 +106,7 @@ namespace ABI.{{context.CurrentNamespace}} { """); writer.IncreaseIndent(); + context.InAbiNamespace = true; } @@ -119,6 +123,7 @@ public void WriteEndAbiNamespace(ProjectionEmitContext context) } #pragma warning restore CA1416 """); + context.InAbiNamespace = false; } } diff --git a/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs index c3ea900ec..2948e9d3e 100644 --- a/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs @@ -16,15 +16,13 @@ internal static class PropertyDefinitionExtensions /// /// Returns whether the property carries the [NoExceptionAttribute]. /// - /// if the property is documented to never throw; otherwise . - public bool IsNoExcept() - => property.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); + public bool IsNoExcept => property.HasWindowsFoundationMetadataAttribute(NoExceptionAttribute); /// /// Returns the (getter, setter) accessor pair of the property. /// /// A tuple of (Getter, Setter) accessor methods, either of which may be . - public (MethodDefinition? Getter, MethodDefinition? Setter) GetPropertyMethods() + public (MethodDefinition? Getter, MethodDefinition? Setter) GetMethods() => (property.GetMethod, property.SetMethod); } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 2e6f27e1e..3dcc17c78 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -3,6 +3,9 @@ using System.Collections.Generic; using AsmResolver.DotNet; +using AsmResolver.DotNet.Signatures; +using AsmResolver.PE.DotNet.Metadata.Tables; +using WindowsRuntime.ProjectionWriter.Metadata; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; namespace WindowsRuntime.ProjectionWriter; @@ -31,28 +34,24 @@ public IEnumerable GetNonSpecialMethods() } /// - /// Returns the set of property accessor methods (get and set) declared by the type's + /// Returns the property accessor methods (get and set) declared by the type's /// properties. Used to filter "regular" methods (non-property, non-event) when emitting /// per-method code in interface bodies. /// - public HashSet GetPropertyAccessorSet() + public IEnumerable GetPropertyAccessors() { - HashSet accessors = []; - foreach (PropertyDefinition prop in type.Properties) { if (prop.GetMethod is MethodDefinition g) { - _ = accessors.Add(g); + yield return g; } if (prop.SetMethod is MethodDefinition s) { - _ = accessors.Add(s); + yield return s; } } - - return accessors; } /// @@ -64,7 +63,7 @@ public HashSet GetPropertyAccessorSet() /// The metadata cache used to resolve interface references. /// The accumulator set to which resolved required interface /// definitions are added. - public void MarkRequiredInterfacesVisited(Metadata.MetadataCache cache, HashSet visited) + public void MarkRequiredInterfacesVisited(MetadataCache cache, HashSet visited) { foreach (InterfaceImplementation impl in type.Interfaces) { @@ -89,6 +88,7 @@ public void MarkRequiredInterfacesVisited(Metadata.MetadataCache cache, HashSet< return impl.Interface; } } + return null; } @@ -101,11 +101,12 @@ public void MarkRequiredInterfacesVisited(Metadata.MetadataCache cache, HashSet< { foreach (MethodDefinition m in type.Methods) { - if (m.IsSpecialName && m.Name == "Invoke") + if (m.IsInvoke) { return m; } } + return null; } @@ -122,27 +123,17 @@ public bool HasDefaultConstructor() return true; } } + return false; } /// - /// Returns whether the type has a base type that is not + /// Returns whether the type has a base type that is not /// (i.e. the type derives from a real WinRT/.NET class). /// public bool HasNonObjectBaseType() { - return type.BaseType is { } bt && !bt.MatchesName("System", "Object"); - } - - /// - /// Returns whether the type has a base type that is neither - /// nor the projection's WindowsRuntime.WindowsRuntimeObject root. - /// - public bool HasNonProjectionBaseClass() - { - return type.BaseType is { } bt - && !bt.MatchesName("System", "Object") - && !bt.MatchesName("WindowsRuntime", "WindowsRuntimeObject"); + return type.BaseType is not (null or CorLibTypeSignature { ElementType: ElementType.Object }); } /// diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 251ddaeeb..2f57cd6e0 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -49,22 +49,22 @@ public bool IsObject() /// if the signature is the projected ; otherwise . public bool IsSystemType() { - if (sig is TypeDefOrRefSignature td && td.Type is { } t) - { - (string ns, string name) = t.Names(); + (string ns, string name) = sig.Names(); - if (ns == "System" && name == "Type") - { - return true; - } + return (ns == "System" && name == "Type") || (ns == WindowsUIXamlInterop && name == TypeName); + } - if (ns == WindowsUIXamlInterop && name == TypeName) - { - return true; - } - } + /// + /// Returns whether the signature is the special / + /// Windows.Foundation.HResult pair (which uses an HResult struct as its ABI form + /// and requires custom marshalling via ABI.System.ExceptionMarshaller). + /// + /// if the signature is the projected HResult/; otherwise . + public bool IsHResultException() + { + (string ns, string name) = sig.Names(); - return false; + return (ns == "System" && name == "Exception") || (ns == WindowsFoundation && name == HResult); } /// @@ -79,10 +79,9 @@ public bool IsNullableT() return false; } - string ns = gi.GenericType?.Namespace?.Value ?? string.Empty; - string name = gi.GenericType?.Name?.Value ?? string.Empty; - return (ns == WindowsFoundation && name == IReferenceGeneric) - || (ns == "System" && name == NullableGeneric); + (string ns, string name) = gi.GenericType.Names(); + + return (ns == WindowsFoundation && name == IReferenceGeneric) || (ns == "System" && name == NullableGeneric); } /// @@ -93,9 +92,9 @@ public bool IsNullableT() /// The inner type argument, or . public TypeSignature? GetNullableInnerType() { - if (sig is GenericInstanceTypeSignature gi && gi.TypeArguments.Count == 1) + if (sig is GenericInstanceTypeSignature { TypeArguments: [var arg] }) { - return gi.TypeArguments[0]; + return arg; } return null; @@ -110,24 +109,6 @@ public bool IsGenericInstance() { return sig is GenericInstanceTypeSignature; } - - /// - /// Returns whether the signature is the special / - /// Windows.Foundation.HResult pair (which uses an HResult struct as its ABI form - /// and requires custom marshalling via ABI.System.ExceptionMarshaller). - /// - /// if the signature is the projected HResult/; otherwise . - public bool IsHResultException() - { - if (sig is not TypeDefOrRefSignature td || td.Type is null) - { - return false; - } - - (string ns, string name) = td.Type.Names(); - return (ns == "System" && name == "Exception") - || (ns == WindowsFoundation && name == HResult); - } } extension(TypeSignature? sig) @@ -141,22 +122,26 @@ public bool IsHResultException() public TypeSignature? StripByRefAndCustomModifiers() { TypeSignature? cur = sig; + while (true) { if (cur is CustomModifierTypeSignature cm) { cur = cm.BaseType; + continue; } if (cur is ByReferenceTypeSignature br) { cur = br.BaseType; + continue; } break; } + return cur; } @@ -168,10 +153,12 @@ public bool IsHResultException() public bool IsByRefType() { TypeSignature? cur = sig; + while (cur is CustomModifierTypeSignature cm) { cur = cm.BaseType; } + return cur is ByReferenceTypeSignature; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index fd9aeee6f..6cfa917b1 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -341,7 +341,7 @@ public static nint Vtable // Build sets of property accessors and event accessors so the first loop below can // iterate "regular" methods (non-property, non-event) only. Do_Abi bodies are emitted in // this order: methods first, then properties (setter before getter), then events. - HashSet propertyAccessors = type.GetPropertyAccessorSet(); + HashSet propertyAccessors = [.. type.GetPropertyAccessors()]; // Local helper to emit a single Do_Abi method body for a given MethodDefinition. void EmitOneDoAbi(MethodDefinition method) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 1ce993dd9..a4a6d89ad 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -257,7 +257,7 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented foreach (PropertyDefinition prop in type.Properties) { - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); string pname = prop.Name?.Value ?? string.Empty; string propType = InterfaceFactory.WritePropType(context, prop); @@ -390,7 +390,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite foreach (PropertyDefinition prop in type.Properties) { - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); string pname = prop.Name?.Value ?? string.Empty; string propType = InterfaceFactory.WritePropType(context, prop); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index b5a27cb33..1f7dcdf81 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -71,31 +71,26 @@ public static unsafe foreach (PropertyDefinition prop in type.Properties) { string pname = prop.Name?.Value ?? string.Empty; - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); string propType = InterfaceFactory.WritePropType(context, prop); - (MethodDefinition? gMethod, MethodDefinition? sMethod) = (getter, setter); - // accessors of the property (the attribute is on the property itself, not on the - // individual accessors). - bool propIsNoExcept = prop.IsNoExcept(); - if (gMethod is not null) + if (prop.GetMethod is { } getter) { - MethodSignatureInfo getSig = new(gMethod); writer.Write(isMultiline: true, $$""" [MethodImpl(MethodImplOptions.NoInlining)] public static unsafe {{propType}} {{pname}}(WindowsRuntimeObjectReference thisReference) """); - EmitAbiMethodBodyIfSimple(writer, context, getSig, methodSlot[gMethod], isNoExcept: propIsNoExcept); + + EmitAbiMethodBodyIfSimple(writer, context, new MethodSignatureInfo(getter), methodSlot[getter], isNoExcept: prop.IsNoExcept); } - if (sMethod is not null) + if (prop.SetMethod is { } setter) { - MethodSignatureInfo setSig = new(sMethod); writer.Write(isMultiline: true, $$""" [MethodImpl(MethodImplOptions.NoInlining)] public static unsafe void {{pname}}(WindowsRuntimeObjectReference thisReference, {{InterfaceFactory.WritePropType(context, prop, isSetProperty: true)}} value) """); - EmitAbiMethodBodyIfSimple(writer, context, setSig, methodSlot[sMethod], paramNameOverride: "value", isNoExcept: propIsNoExcept); + + EmitAbiMethodBodyIfSimple(writer, context, new MethodSignatureInfo(setter), methodSlot[setter], paramNameOverride: "value", isNoExcept: prop.IsNoExcept); } } diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 4869fae66..d5696f63f 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -399,7 +399,7 @@ public static event {{eventType}} {{evtName}} foreach (PropertyDefinition prop in staticIface.Properties) { string propName = prop.Name?.Value ?? string.Empty; - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); string propType = InterfaceFactory.WritePropType(context, prop); if (!properties.TryGetValue(propName, out StaticPropertyAccessorState? state)) @@ -708,7 +708,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont } // base call when type has a non-object base class - bool hasBaseClass = type.HasNonProjectionBaseClass(); + bool hasBaseClass = type.HasNonObjectBaseType(); if (hasBaseClass) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index cb7b6a87d..e2a9b81ef 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -360,7 +360,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE foreach (PropertyDefinition prop in ifaceType.Properties) { string name = prop.Name?.Value ?? string.Empty; - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); if (!propertyState.TryGetValue(name, out PropertyAccessorState? state)) { diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 00ff598d3..2142e43c4 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -199,7 +199,7 @@ private static void WriteStaticFactoryMethod(IndentedTextWriter writer, Projecti private static void WriteStaticFactoryProperty(IndentedTextWriter writer, ProjectionEmitContext context, PropertyDefinition prop, string projectedTypeName) { string propName = prop.Name?.Value ?? string.Empty; - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); string propType = GetFactoryPropertyType(context, prop); // Single-line form when no setter is present. diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 62c85028e..5595404cb 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -231,7 +231,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro foreach (PropertyDefinition prop in type.Properties) { - (MethodDefinition? getter, MethodDefinition? setter) = prop.GetPropertyMethods(); + (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); // Add 'new' when this interface has a setter-only property AND a property of the same // name exists on a base interface (typically the getter-only counterpart). This hides // the inherited member. From 561620691b06c9727041af79b63900e3fe2c1f9c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:12:45 -0700 Subject: [PATCH 094/171] Move StripByRefAndCustomModifiers to AbiTypeHelpers Remove the StripByRefAndCustomModifiers extension from TypeSignatureExtensions and add a public implementation in AbiTypeHelpers (adjusted nullability and ordering). Update ParameterCategoryResolver to call AbiTypeHelpers.StripByRefAndCustomModifiers and add the needed using. Several helper methods in AbiTypeHelpers were made public for broader use, an unused using was removed, and the large IsDelegateInvokeNativeSupported helper was deleted. These changes centralize ABI type helper logic and expose utilities for use across the writer code. --- .../Extensions/TypeSignatureExtensions.cs | 32 ----- .../Helpers/AbiTypeHelpers.cs | 125 +++--------------- .../Resolvers/ParameterCategoryResolver.cs | 5 +- 3 files changed, 23 insertions(+), 139 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 2f57cd6e0..6315ae2af 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -113,38 +113,6 @@ public bool IsGenericInstance() extension(TypeSignature? sig) { - /// - /// Strips trailing and - /// wrappers from the signature, returning the underlying signature (or - /// if the input is ). - /// - /// The underlying signature with byref + custom-modifier wrappers stripped. - public TypeSignature? StripByRefAndCustomModifiers() - { - TypeSignature? cur = sig; - - while (true) - { - if (cur is CustomModifierTypeSignature cm) - { - cur = cm.BaseType; - - continue; - } - - if (cur is ByReferenceTypeSignature br) - { - cur = br.BaseType; - - continue; - } - - break; - } - - return cur; - } - /// /// Returns whether the signature represents a by-reference type, peeling any /// custom-modifier wrappers (e.g. modreq[InAttribute]) before checking. diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 51fea2909..7a8447946 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -9,7 +9,6 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; -using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -25,7 +24,7 @@ internal static partial class AbiTypeHelpers /// /// Returns the parent class for an interface marked [ExclusiveToAttribute(typeof(T))]. /// - internal static TypeDefinition? GetExclusiveToType(MetadataCache cache, TypeDefinition iface) + public static TypeDefinition? GetExclusiveToType(MetadataCache cache, TypeDefinition iface) { for (int i = 0; i < iface.CustomAttributes.Count; i++) { @@ -104,7 +103,7 @@ public static string GetVirtualMethodName(TypeDefinition type, MethodDefinition /// Returns the metadata-derived name for the return parameter, or the conventional /// __return_value__ placeholder when the metadata does not name it. /// - internal static string GetReturnParamName(MethodSignatureInfo sig) + public static string GetReturnParamName(MethodSignatureInfo sig) { string? n = sig.ReturnParameter?.Name?.Value; @@ -120,7 +119,7 @@ internal static string GetReturnParamName(MethodSignatureInfo sig) /// Returns the local-variable name for the return parameter on the server side. /// abi_marshaler::get_marshaler_local() which prefixes __ to the param name. /// - internal static string GetReturnLocalName(MethodSignatureInfo sig) + public static string GetReturnLocalName(MethodSignatureInfo sig) { return "__" + GetReturnParamName(sig); } @@ -128,7 +127,7 @@ internal static string GetReturnLocalName(MethodSignatureInfo sig) /// /// Returns '__<returnName>Size' — by default '____return_value__Size' for the standard '__return_value__' return param. /// - internal static string GetReturnSizeParamName(MethodSignatureInfo sig) + public static string GetReturnSizeParamName(MethodSignatureInfo sig) { return "__" + GetReturnParamName(sig) + "Size"; } @@ -136,7 +135,7 @@ internal static string GetReturnSizeParamName(MethodSignatureInfo sig) /// /// Build a method-to-event map for add/remove accessors of a type. /// - internal static Dictionary? BuildEventMethodMap(TypeDefinition type) + public static Dictionary? BuildEventMethodMap(TypeDefinition type) { if (type.Events.Count == 0) { @@ -191,103 +190,10 @@ public static void WriteIidGuidReference(IndentedTextWriter writer, ProjectionEm IidExpressionGenerator.WriteIidGuidPropertyName(writer, context, type); } - /// - /// True if EmitNativeDelegateBody can emit a real (non-throw) body for this signature. - /// - internal static bool IsDelegateInvokeNativeSupported(MetadataCache cache, MethodSignatureInfo sig) - { - TypeSignature? rt = sig.ReturnType; - - if (rt is not null) - { - if (rt.IsHResultException()) - { - return false; - } - - if (!(IsBlittablePrimitive(cache, rt) || IsAnyStruct(cache, rt) || rt.IsString() || IsRuntimeClassOrInterface(cache, rt) || rt.IsObject() || rt.IsGenericInstance() || IsComplexStruct(cache, rt))) - { - return false; - } - } - - foreach (ParameterInfo p in sig.Parameters) - { - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - - if (cat.IsArrayInput()) - { - if (p.Type is SzArrayTypeSignature szP) - { - if (IsBlittablePrimitive(cache, szP.BaseType)) - { - continue; - } - - if (IsAnyStruct(cache, szP.BaseType)) - { - continue; - } - } - - return false; - } - - if (cat != ParameterCategory.In) - { - return false; - } - - if (p.Type.IsHResultException()) - { - return false; - } - - if (IsBlittablePrimitive(cache, p.Type)) - { - continue; - } - - if (IsAnyStruct(cache, p.Type)) - { - continue; - } - - if (p.Type.IsString()) - { - continue; - } - - if (IsRuntimeClassOrInterface(cache, p.Type)) - { - continue; - } - - if (p.Type.IsObject()) - { - continue; - } - - if (p.Type.IsGenericInstance()) - { - continue; - } - - if (IsComplexStruct(cache, p.Type)) - { - continue; - } - - return false; - } - - return true; - } - /// /// True if the interface has at least one non-special method, property, or non-skipped event. /// - internal static bool HasEmittableMembers(TypeDefinition iface, bool skipExclusiveEvents) + public static bool HasEmittableMembers(TypeDefinition iface, bool skipExclusiveEvents) { foreach (MethodDefinition m in iface.Methods) { @@ -313,7 +219,7 @@ internal static bool HasEmittableMembers(TypeDefinition iface, bool skipExclusiv /// /// Returns the number of methods (including special accessors) on the interface. /// - internal static int CountMethods(TypeDefinition iface) + public static int CountMethods(TypeDefinition iface) { return iface.Methods.Count; } @@ -321,7 +227,7 @@ internal static int CountMethods(TypeDefinition iface) /// /// Returns the number of base classes between and . /// - internal static int GetClassHierarchyIndex(MetadataCache cache, TypeDefinition classType) + public static int GetClassHierarchyIndex(MetadataCache cache, TypeDefinition classType) { if (classType.BaseType is null) { @@ -354,7 +260,7 @@ internal static int GetClassHierarchyIndex(MetadataCache cache, TypeDefinition c /// /// Returns whether two interface types refer to the same interface by namespace+name (used to compare interfaces across module boundaries). /// - internal static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) + public static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) { if (a == b) { @@ -365,22 +271,29 @@ internal static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) && (a.Name?.Value ?? string.Empty) == (b.Name?.Value ?? string.Empty); } - /// Strips ByReferenceTypeSignature and CustomModifierTypeSignature wrappers - /// to get the underlying type signature. - internal static TypeSignature StripByRefAndCustomModifiers(TypeSignature sig) + /// + /// Strips trailing and + /// wrappers from the signature, returning the underlying signature (or + /// if the input is ). + /// + /// The underlying signature with byref + custom-modifier wrappers stripped. + public static TypeSignature StripByRefAndCustomModifiers(TypeSignature sig) { TypeSignature current = sig; + while (true) { if (current is ByReferenceTypeSignature br) { current = br.BaseType; + continue; } if (current is CustomModifierTypeSignature cm) { current = cm.BaseType; + continue; } diff --git a/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs b/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs index 1681d0994..80e7aa3ca 100644 --- a/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Models; namespace WindowsRuntime.ProjectionWriter.Resolvers; @@ -22,13 +23,15 @@ public static ParameterCategory GetParamCategory(ParameterInfo p) bool isArray = p.Type is SzArrayTypeSignature; bool isOut = p.Parameter.Definition?.IsOut == true; bool isIn = p.Parameter.Definition?.IsIn == true; + // Check both the captured signature type and the parameter's own type (handles cases where // the signature is wrapped in a ByReferenceTypeSignature only on one side after substitution). // Also peel custom modifiers (e.g. modreq[InAttribute]) which can hide a ByRef beneath. bool isByRef = p.Type.IsByRefType() || p.Parameter.ParameterType.IsByRefType(); + // If byref and underlying is an array, treat as array param (PassArray/ReceiveArray/FillArray) // based on in/out flags. WinRT metadata represents 'out byte[]' as 'byte[]&' with [out]. - bool isByRefArray = isByRef && p.Type.StripByRefAndCustomModifiers() is SzArrayTypeSignature; + bool isByRefArray = isByRef && AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type) is SzArrayTypeSignature; if (isArray || isByRefArray) { From 2df8920e39a9324d19646b495004f7a67c073013 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:15:26 -0700 Subject: [PATCH 095/171] Annotate IsByRefType and tidy TypeSignature extensions Add a NotNullWhen(true) annotation for the TypeSignature? parameter used by IsByRefType and move the method into the annotated extension block to improve nullable analysis. Add using System.Diagnostics.CodeAnalysis. Replace explicit corlib element checks with existing helper methods (IsString/IsObject/IsGenericInstance) and remove unnecessary null-forgiving operators (sig!) when calling helpers like StripByRefAndCustomModifiers. Minor refactor and formatting cleanup for clarity. --- .../Extensions/TypeSignatureExtensions.cs | 61 ++++++++++--------- 1 file changed, 32 insertions(+), 29 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 6315ae2af..17ab959a0 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System.Diagnostics.CodeAnalysis; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Resolvers; @@ -109,26 +110,6 @@ public bool IsGenericInstance() { return sig is GenericInstanceTypeSignature; } - } - - extension(TypeSignature? sig) - { - /// - /// Returns whether the signature represents a by-reference type, peeling any - /// custom-modifier wrappers (e.g. modreq[InAttribute]) before checking. - /// - /// if the signature (after peeling custom modifiers) is a ; otherwise . - public bool IsByRefType() - { - TypeSignature? cur = sig; - - while (cur is CustomModifierTypeSignature cm) - { - cur = cm.BaseType; - } - - return cur is ByReferenceTypeSignature; - } /// /// Returns whether the signature has the "ABI reference-pointer" shape: it crosses the @@ -144,10 +125,11 @@ public bool IsByRefType() /// public bool IsAbiRefLike(AbiTypeShapeResolver resolver) { - return (sig is CorLibTypeSignature corlibStr && corlibStr.ElementType == ElementType.String) - || resolver.IsRuntimeClassOrInterface(sig!) - || (sig is CorLibTypeSignature corlibObj && corlibObj.ElementType == ElementType.Object) - || sig is GenericInstanceTypeSignature; + return + sig.IsString() || + sig.IsObject() || + sig.IsGenericInstance() || + resolver.IsRuntimeClassOrInterface(sig); } /// @@ -162,9 +144,10 @@ public bool IsAbiRefLike(AbiTypeShapeResolver resolver) /// if the signature flows as a void* when used as an SZ-array element; otherwise . public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) { - return (sig is CorLibTypeSignature corlibStr && corlibStr.ElementType == ElementType.String) - || resolver.IsRuntimeClassOrInterface(sig!) - || (sig is CorLibTypeSignature corlibObj && corlibObj.ElementType == ElementType.Object); + return + sig.IsString() || + sig.IsObject() || + resolver.IsRuntimeClassOrInterface(sig); } /// @@ -174,7 +157,7 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) /// public SzArrayTypeSignature? AsSzArray() { - return Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig!) as SzArrayTypeSignature; + return Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig) as SzArrayTypeSignature; } /// @@ -184,7 +167,27 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) /// public TypeSignature? SzArrayElement() { - return (Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig!) as SzArrayTypeSignature)?.BaseType; + return (Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig) as SzArrayTypeSignature)?.BaseType; + } + } + + extension([NotNullWhen(true)] TypeSignature? sig) + { + /// + /// Returns whether the signature represents a by-reference type, peeling any + /// custom-modifier wrappers (e.g. modreq[InAttribute]) before checking. + /// + /// if the signature (after peeling custom modifiers) is a ; otherwise . + public bool IsByRefType() + { + TypeSignature? cur = sig; + + while (cur is CustomModifierTypeSignature cm) + { + cur = cm.BaseType; + } + + return cur is ByReferenceTypeSignature; } } } \ No newline at end of file From dfd302707aa9f1520ee932b390a0bc4bda4f0f8c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:32:11 -0700 Subject: [PATCH 096/171] Improve projection writer emission and refactor Refactor ProjectionFileBuilder to simplify TypeCategory handling with pattern matching and make several writer methods private. Improve enum/struct/attribute emission: per-field platform attributes for enum fields, forward-declare API contract enums, generate struct constructors, readonly properties, equality operators and GetHashCode, and emit attribute/field formatting tweaks. Add GetConstructors extension to enumerate constructors, trim trailing newline when inlining custom attributes, and remove redundant null-or-empty fallbacks for some identifier writes. Misc fixes in AbiStructFactory and InterfaceFactory to normalize emitted member names. --- .../Builders/ProjectionFileBuilder.cs | 120 +++++++++--------- .../Extensions/TypeDefinitionExtensions.cs | 14 ++ .../Factories/AbiStructFactory.cs | 2 +- .../Factories/CustomAttributeFactory.cs | 2 + .../Factories/InterfaceFactory.cs | 4 +- 5 files changed, 77 insertions(+), 65 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index ca68a619b..c5707a155 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -30,16 +30,11 @@ public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext co { switch (category) { + case TypeCategory.Class when TypeCategorization.IsAttributeType(type): + WriteAttribute(writer, context, type); + break; case TypeCategory.Class: - if (TypeCategorization.IsAttributeType(type)) - { - WriteAttribute(writer, context, type); - } - else - { - ClassFactory.WriteClass(writer, context, type); - } - + ClassFactory.WriteClass(writer, context, type); break; case TypeCategory.Delegate: WriteDelegate(writer, context, type); @@ -50,16 +45,11 @@ public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext co case TypeCategory.Interface: InterfaceFactory.WriteInterface(writer, context, type); break; + case TypeCategory.Struct when TypeCategorization.IsApiContractType(type): + WriteContract(writer, context, type); + break; case TypeCategory.Struct: - if (TypeCategorization.IsApiContractType(type)) - { - WriteContract(writer, context, type); - } - else - { - WriteStruct(writer, context, type); - } - + WriteStruct(writer, context, type); break; default: throw WellKnownProjectionWriterExceptions.UnknownTypeCategory(category); @@ -97,7 +87,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext /// /// Writes a projected enum (with [Flags] when applicable). /// - public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.Component) { @@ -116,9 +106,7 @@ public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext co WriteWinRTReferenceTypeAttributeCallback refTypeAttr = MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(context, type); writer.WriteLine(); - writer.WriteLineIf(isFlags, "[Flags]"); - writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} {{valueTypeAttr}} @@ -127,6 +115,7 @@ public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext co {{refTypeAttr}} {{accessibility}} enum {{typeName}} : {{enumUnderlyingType}} """); + using (writer.WriteBlock()) { foreach (FieldDefinition field in type.Fields) @@ -138,11 +127,14 @@ public static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext co string fieldName = field.Name?.Value ?? string.Empty; string constantValue = FormatConstant(field.Constant); + // Emits per-enum-field [SupportedOSPlatform] when the field has a [ContractVersion]. CustomAttributeFactory.WritePlatformAttribute(writer, context, field); + writer.WriteLine($"{fieldName} = unchecked(({enumUnderlyingType}){constantValue}),"); } } + writer.WriteLine(); } @@ -183,15 +175,16 @@ private static string FormatHexAlternate(uint v) /// /// Writes a projected struct. /// - public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.Component) { return; } - // Collect field info List<(string TypeStr, string Name, string ParamName, bool IsInterface)> fields = []; + + // Collect field info foreach (FieldDefinition field in type.Fields) { if (field.IsStatic || field.Signature is null) @@ -226,6 +219,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); WriteWinRTReferenceTypeAttributeCallback refTypeAttr = MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(context, type); + string partial = hasAddition ? " partial" : ""; writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} @@ -235,8 +229,10 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext {{refTypeAttr}} public{{partial}} struct {{projectionName}} : IEquatable<{{projectionName}}> """); + using (writer.WriteBlock()) { + // Emit the constructor declaration writer.Write($"public {projectionName}("); for (int i = 0; i < fields.Count; i++) { @@ -246,13 +242,14 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext writer.Write($"{fields[i].TypeStr} {name}"); } + // Emit the constructor body (just assigning each field) writer.WriteLine(")"); using (writer.WriteBlock()) { foreach ((string _, string name, string paramName, bool _) in fields) { - // When the param name matches the field name (i.e. ToCamelCase couldn't change casing), - // qualify with this. to disambiguate. + // When the param name matches the field name (i.e. 'ToCamelCase' couldn't + // change casing), qualify with 'this.' to disambiguate. WriteEscapedIdentifierCallback paramRef = IdentifierEscaping.WriteEscapedIdentifier(paramName); if (name == paramName) { @@ -267,42 +264,50 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext writer.WriteLine(); } - // properties + // Properties (all getters are readonly) foreach ((string typeStr, string name, string _, bool _) in fields) { - writer.WriteLine($"public {typeStr} {name}"); - using (writer.WriteBlock()) - { - writer.WriteLine("readonly get; set;"); - } + writer.WriteLine($$""" + public {{typeStr}} {{name}} + { + readonly get; set; + } + """); } - // == + // Overridden '==' operator writer.Write($"public static bool operator ==({projectionName} x, {projectionName} y) => "); + // If we have any fields, we just emit a direct comparison for each of them if (fields.Count == 0) { - writer.Write("true"); + writer.WriteLine("true;"); } else { for (int i = 0; i < fields.Count; i++) { writer.WriteIf(i > 0, " && "); - writer.Write($"x.{fields[i].Name} == y.{fields[i].Name}"); } + + writer.WriteLine(";"); } - writer.WriteLine(";"); - writer.WriteLine($"public static bool operator !=({projectionName} x, {projectionName} y) => !(x == y);"); - writer.WriteLine($"public bool Equals({projectionName} other) => this == other;"); - writer.WriteLine($"public override bool Equals(object obj) => obj is {projectionName} that && this == that;"); + // Other equality operators + writer.WriteLine($""" + public static bool operator !=({projectionName} x, {projectionName} y) => !(x == y); + public bool Equals({projectionName} other) => this == other; + public override bool Equals(object obj) => obj is {projectionName} that && this == that; + """); + + // Also override 'GetHashCode' (especially important for structs, as it avoids reflection) writer.Write("public override int GetHashCode() => "); + // If we have aby fields, just combine the hashcode of all fields if (fields.Count == 0) { - writer.Write("0"); + writer.WriteLine("0;"); } else { @@ -312,9 +317,9 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext writer.Write($"{fields[i].Name}.GetHashCode()"); } - } - writer.WriteLine(";"); + writer.WriteLine(";"); + } } writer.WriteLine(); @@ -323,7 +328,7 @@ public static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext /// /// Writes a projected API contract (an empty enum stand-in). /// - public static void WriteContract(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + private static void WriteContract(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.Component) { @@ -333,26 +338,21 @@ public static void WriteContract(IndentedTextWriter writer, ProjectionEmitContex string typeName = type.Name?.Value ?? string.Empty; CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); - writer.WriteLine(isMultiline: true, $$""" - {{context.Settings.InternalAccessibility}} enum {{typeName}} - { - } - """); + + writer.WriteLine($"{context.Settings.InternalAccessibility} enum {typeName};"); } /// /// Writes a projected delegate. /// - public static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + private static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { if (context.Settings.Component) { return; } - MethodDefinition? invoke = type.GetDelegateInvoke(); - - if (invoke is null) + if (type.GetDelegateInvoke() is not { } invoke) { return; } @@ -383,7 +383,7 @@ public static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitContex /// /// Writes a projected attribute class. /// - public static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + private static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string typeName = type.Name?.Value ?? string.Empty; @@ -396,20 +396,15 @@ public static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitConte {{customAttrs}} {{context.Settings.InternalAccessibility}} sealed class {{typeName}} : Attribute """); + using (writer.WriteBlock()) { // Constructors - foreach (MethodDefinition method in type.Methods) + foreach (MethodDefinition method in type.GetConstructors()) { - if (method.Name?.Value != ".ctor") - { - continue; - } + WriteParameterListCallback parameterList = MethodFactory.WriteParameterList(context, new MethodSignatureInfo(method)); - MethodSignatureInfo sig = new(method); - writer.Write($"public {typeName}("); - MethodFactory.WriteParameterList(writer, context, sig); - writer.WriteLine("){}"); + writer.Write($$"""public {{typeName}}({{parameterList}}) { }"""); } // Fields @@ -421,7 +416,8 @@ public static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitConte } WriteProjectionTypeCallback fieldType = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(field.Signature.FieldType)); - writer.WriteLine($"public {fieldType} {field.Name?.Value ?? string.Empty};"); + + writer.WriteLine($"public {fieldType} {field.Name?.Value};"); } } } diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 3dcc17c78..2ffc1d055 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -33,6 +33,20 @@ public IEnumerable GetNonSpecialMethods() } } + /// + /// Returns the constructors for the current type. + /// + public IEnumerable GetConstructors() + { + foreach (MethodDefinition method in type.Methods) + { + if (method.IsConstructor) + { + yield return method; + } + } + } + /// /// Returns the property accessor methods (get and set) declared by the type's /// properties. Used to filter "regular" methods (non-property, non-event) when emitting diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index bcad0e219..801d78d31 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -59,7 +59,7 @@ public static void WriteAbiStruct(IndentedTextWriter writer, ProjectionEmitConte TypeSignature ft = field.Signature.FieldType; string fieldType = GetAbiFieldType(context, ft); - writer.WriteLine($"public {fieldType} {field.Name?.Value ?? string.Empty};"); + writer.WriteLine($"public {fieldType} {field.Name?.Value};"); } } writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index 0c753b1e3..d7eabd891 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -489,7 +489,9 @@ public static WriteTypeCustomAttributesCallback WriteTypeCustomAttributes(Projec internal static void WriteTypeCustomAttributesBody(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, bool enablePlatformAttrib) { int before = writer.Length; + WriteCustomAttributes(writer, context, type, enablePlatformAttrib); + // If anything was written, the buffer ends with a trailing newline that came from the // last attribute's WriteLine. Trim it so the callback can be inlined into a multiline // template line without producing a stray blank line. diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 5595404cb..03f2837b6 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -239,7 +239,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro && TryFindPropertyInBaseInterfaces(context.Cache, type, prop.Name?.Value ?? string.Empty, out _)) ? "new " : string.Empty; string propType = WritePropType(context, prop); - writer.Write($"{newKeyword}{propType} {prop.Name?.Value ?? string.Empty} {{"); + writer.Write($"{newKeyword}{propType} {prop.Name?.Value} {{"); writer.WriteIf(getter is not null || setter is not null, " get;"); @@ -251,7 +251,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro foreach (EventDefinition evt in type.Events) { WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); - writer.WriteLine($"event {eventType} {evt.Name?.Value ?? string.Empty};"); + writer.WriteLine($"event {eventType} {evt.Name?.Value};"); } } From 549237d4833894d4c9e236324bb0f17cb066540a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:38:27 -0700 Subject: [PATCH 097/171] Extract constant formatting to extension Move constant-to-C# literal formatting out of ProjectionFileBuilder into a new ConstantExtensions.FormatLiteral() extension method. Update ProjectionFileBuilder to call field.Constant.FormatLiteral(), add the new Extensions/ConstantExtensions.cs file, and remove the old FormatConstant and FormatField helpers from ProjectionFileBuilder and MethodFactory. Clean up related using directives. --- .../Builders/ProjectionFileBuilder.cs | 39 +-------------- .../Extensions/ConstantExtensions.cs | 49 +++++++++++++++++++ .../Factories/MethodFactory.cs | 17 ------- 3 files changed, 50 insertions(+), 55 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Extensions/ConstantExtensions.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index c5707a155..d6ad0b98a 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -1,11 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using System; using System.Collections.Generic; -using System.Globalization; using AsmResolver.DotNet; -using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Errors; using WindowsRuntime.ProjectionWriter.Factories; using WindowsRuntime.ProjectionWriter.Factories.Callbacks; @@ -126,7 +123,7 @@ private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext c } string fieldName = field.Name?.Value ?? string.Empty; - string constantValue = FormatConstant(field.Constant); + string constantValue = field.Constant.FormatLiteral(); // Emits per-enum-field [SupportedOSPlatform] when the field has a [ContractVersion]. CustomAttributeFactory.WritePlatformAttribute(writer, context, field); @@ -138,40 +135,6 @@ private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext c writer.WriteLine(); } - /// - /// Formats a metadata Constant value as a C# literal. - /// - internal static string FormatConstant(Constant constant) - { - // The Constant.Value contains raw bytes representing the value - ElementType type = constant.Type; - byte[] data = constant.Value?.Data ?? []; - return type switch - { - ElementType.I1 => ((sbyte)data[0]).ToString(CultureInfo.InvariantCulture), - ElementType.U1 => data[0].ToString(CultureInfo.InvariantCulture), - ElementType.I2 => BitConverter.ToInt16(data, 0).ToString(CultureInfo.InvariantCulture), - ElementType.U2 => BitConverter.ToUInt16(data, 0).ToString(CultureInfo.InvariantCulture), - // I4/U4 use printf "%#0x" semantics: 0 -> "0", non-zero -> "0x" - ElementType.I4 => FormatHexAlternate((uint)BitConverter.ToInt32(data, 0)), - ElementType.U4 => FormatHexAlternate(BitConverter.ToUInt32(data, 0)), - ElementType.I8 => BitConverter.ToInt64(data, 0).ToString(CultureInfo.InvariantCulture), - ElementType.U8 => BitConverter.ToUInt64(data, 0).ToString(CultureInfo.InvariantCulture), - _ => "0" - }; - } - - private static string FormatHexAlternate(uint v) - { - // Match printf "%#0x" semantics: for 0, output "0"; for non-zero, output "0x" with no padding. - if (v == 0) - { - return "0"; - } - - return "0x" + v.ToString("x", CultureInfo.InvariantCulture); - } - /// /// Writes a projected struct. /// diff --git a/src/WinRT.Projection.Writer/Extensions/ConstantExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ConstantExtensions.cs new file mode 100644 index 000000000..ae7eae499 --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/ConstantExtensions.cs @@ -0,0 +1,49 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System; +using System.Globalization; +using AsmResolver.DotNet; +using AsmResolver.PE.DotNet.Metadata.Tables; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class ConstantExtensions +{ + /// The input constant. + extension(Constant constant) + { + /// + /// Formats a metadata constant value as a C# literal. + /// + public string FormatLiteral() + { + static string FormatHexValue(uint value) + { + // Match printf "%#0x" semantics: for '0', output "0"; for non-zero, output "0x" with no padding + return value == 0 + ? "0" + : $"0x{value:x}"; + } + + // The data contains raw bytes representing the value + byte[] data = constant.Value?.Data ?? []; + + return constant.Type switch + { + ElementType.I1 => ((sbyte)data[0]).ToString(CultureInfo.InvariantCulture), + ElementType.U1 => data[0].ToString(CultureInfo.InvariantCulture), + ElementType.I2 => BitConverter.ToInt16(data, 0).ToString(CultureInfo.InvariantCulture), + ElementType.U2 => BitConverter.ToUInt16(data, 0).ToString(CultureInfo.InvariantCulture), + ElementType.I4 => FormatHexValue((uint)BitConverter.ToInt32(data, 0)), + ElementType.U4 => FormatHexValue(BitConverter.ToUInt32(data, 0)), + ElementType.I8 => BitConverter.ToInt64(data, 0).ToString(CultureInfo.InvariantCulture), + ElementType.U8 => BitConverter.ToUInt64(data, 0).ToString(CultureInfo.InvariantCulture), + _ => "0" + }; + } + } +} \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index 3860c4810..0beb9ac00 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -1,9 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; -using WindowsRuntime.ProjectionWriter.Builders; using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; @@ -230,19 +228,4 @@ public static WriteCallArgumentsCallback WriteCallArguments(ProjectionEmitContex { return new(context, sig, leadingComma); } - - /// - /// Returns the C# literal text for a constant field's value (or empty when no constant). - /// - /// The field definition. - /// The formatted constant value, or an empty string. - public static string FormatField(FieldDefinition field) - { - if (field.Constant is null) - { - return string.Empty; - } - - return ProjectionFileBuilder.FormatConstant(field.Constant); - } } From c48284685adaa36379ac76f523f711592782169f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:48:52 -0700 Subject: [PATCH 098/171] Remove Embedded projection-mode leftover The `Embedded` flag was a 2.x leftover that flipped projected-type visibility to `internal` when the projection was embedded into a consuming library. CsWinRT 3.0 distributes reference projections instead, so this mode has no meaning in the writer. Delete it along with the now-redundant `InternalAccessibility` extension (with `Embedded` gone, `InternalAccessibility` was just `settings.Internal ? "internal" : "public"`). Removed: - `Settings.Embedded` (Generation/Settings.cs) - `ProjectionWriterOptions.Embedded` (the public API option) - `Extensions/SettingsExtensions.cs` (entire file -- only had `InternalAccessibility`) - `ReferenceProjectionGeneratorArgs.Embedded` + the `--embedded` CLI flag mapping - `RunCsWinRTProjectionRefGenerator.Embedded` MSBuild task property + the `--embedded` response-file emission - `Embedded="$(CsWinRTEmbedded)"` attribute on the `RunCsWinRTProjectionRefGenerator` task invocation in `nuget/Microsoft.Windows.CsWinRT.targets` Migrated 5 `context.Settings.InternalAccessibility` call sites in `ProjectionFileBuilder.cs` (3), `ClassFactory.cs` (1), and `AbiStructFactory.cs` (1) to `context.Settings.Internal ? "internal" : "public"` inline ternaries. The `CsWinRTEmbedded` MSBuild property in `Microsoft.Windows.CsWinRT.targets` is still consulted by the C++ `cswinrt.exe` path (`-embedded` arg, line ~290), which is the OLD-target invocation; left untouched since that code is outside the writer's scope. Validation: 763/763 byte-identical against a fresh baseline captured at HEAD~1 across pushnot/evwithui/windows scenarios; all projects (Writer, TestRunner, Ref.Generator, Generator.Tasks) build with 0 warnings, 0 errors. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- nuget/Microsoft.Windows.CsWinRT.targets | 1 - .../RunCsWinRTProjectionRefGenerator.cs | 11 ---------- .../ReferenceProjectionGenerator.cs | 1 - ...eferenceProjectionGeneratorArgs.Parsing.cs | 1 - .../ReferenceProjectionGeneratorArgs.cs | 7 ------ .../Builders/ProjectionFileBuilder.cs | 6 ++--- .../Extensions/SettingsExtensions.cs | 22 ------------------- .../Factories/AbiStructFactory.cs | 2 +- .../Factories/ClassFactory.cs | 2 +- .../Generation/Settings.cs | 5 ----- .../ProjectionWriter.cs | 1 - .../ProjectionWriterOptions.cs | 5 ----- 12 files changed, 5 insertions(+), 59 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Extensions/SettingsExtensions.cs diff --git a/nuget/Microsoft.Windows.CsWinRT.targets b/nuget/Microsoft.Windows.CsWinRT.targets index cb4a1adc7..b86ba5688 100644 --- a/nuget/Microsoft.Windows.CsWinRT.targets +++ b/nuget/Microsoft.Windows.CsWinRT.targets @@ -405,7 +405,6 @@ $(CsWinRTInternalProjection) ExcludeNamespaces="@(_CsWinRTRefExcludes)" Verbose="$(CsWinRTMessageImportance.Equals('high'))" Component="$(CsWinRTComponent)" - Embedded="$(CsWinRTEmbedded)" PublicEnums="$(CsWinRTEmbeddedPublicEnums)" PublicExclusiveTo="$(CsWinRTPublicExclusiveToInterfaces)" IdicExclusiveTo="$(CsWinRTDynamicallyInterfaceCastableExclusiveTo)" diff --git a/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs b/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs index 187ba044d..d1e148bf8 100644 --- a/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs +++ b/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs @@ -79,12 +79,6 @@ public sealed class RunCsWinRTProjectionRefGenerator : ToolTask /// public bool InternalProjection { get; set; } - /// - /// Gets or sets whether to generate an embedded projection. Mirrors the C++ '-embedded' arg. - /// CsWinRT 3.0 leftover; preserved for OLD-target parity. - /// - public bool Embedded { get; set; } - /// /// Gets or sets whether to emit enums as public when used with the embedded option. /// Mirrors the C++ '-public_enums' arg. @@ -263,11 +257,6 @@ protected override string GenerateResponseFileCommands() AppendResponseFileCommand(args, "--internal", "true"); } - if (Embedded) - { - AppendResponseFileCommand(args, "--embedded", "true"); - } - if (PublicEnums) { AppendResponseFileCommand(args, "--public-enums", "true"); diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs index a73c9e684..3d1a7ec86 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs @@ -104,7 +104,6 @@ private static ProjectionWriterOptions BuildWriterOptions(ReferenceProjectionGen Verbose = args.Verbose, Component = args.Component, Internal = args.Internal, - Embedded = args.Embedded, PublicEnums = args.PublicEnums, PublicExclusiveTo = args.PublicExclusiveTo, IdicExclusiveTo = args.IdicExclusiveTo, diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs index 3b9ef440b..d4a70feaa 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs @@ -88,7 +88,6 @@ public static ReferenceProjectionGeneratorArgs ParseFromResponseFile(string path Verbose = GetOptionalBoolArgument(argsMap, nameof(Verbose)), Component = GetOptionalBoolArgument(argsMap, nameof(Component)), Internal = GetOptionalBoolArgument(argsMap, nameof(Internal)), - Embedded = GetOptionalBoolArgument(argsMap, nameof(Embedded)), PublicEnums = GetOptionalBoolArgument(argsMap, nameof(PublicEnums)), PublicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(PublicExclusiveTo)), IdicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(IdicExclusiveTo)), diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs index c5667eccf..fb5010c1d 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs @@ -53,13 +53,6 @@ internal sealed partial class ReferenceProjectionGeneratorArgs [CommandLineArgumentName("--internal")] public bool Internal { get; init; } - /// - /// Gets whether to generate an embedded projection. - /// CsWinRT 3.0 leftover; preserved for OLD-target parity. - /// - [CommandLineArgumentName("--embedded")] - public bool Embedded { get; init; } - /// /// Gets whether to emit enums as public when used with the embedded option. /// CsWinRT 3.0 leftover; preserved for OLD-target parity. diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index d6ad0b98a..5397cd7d4 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -302,7 +302,7 @@ private static void WriteContract(IndentedTextWriter writer, ProjectionEmitConte CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); - writer.WriteLine($"{context.Settings.InternalAccessibility} enum {typeName};"); + writer.WriteLine($"{(context.Settings.Internal ? "internal" : "public")} enum {typeName};"); } /// @@ -339,7 +339,7 @@ private static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitConte {{customAttrs}} {{comWrappersAttr}} {{guidAttr}} - {{context.Settings.InternalAccessibility}} delegate {{ret}} {{typedefName}}{{typeParams}}({{parms}}); + {{(context.Settings.Internal ? "internal" : "public")}} delegate {{ret}} {{typedefName}}{{typeParams}}({{parms}}); """); } @@ -357,7 +357,7 @@ private static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitCont writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} {{customAttrs}} - {{context.Settings.InternalAccessibility}} sealed class {{typeName}} : Attribute + {{(context.Settings.Internal ? "internal" : "public")}} sealed class {{typeName}} : Attribute """); using (writer.WriteBlock()) diff --git a/src/WinRT.Projection.Writer/Extensions/SettingsExtensions.cs b/src/WinRT.Projection.Writer/Extensions/SettingsExtensions.cs deleted file mode 100644 index e74460a0d..000000000 --- a/src/WinRT.Projection.Writer/Extensions/SettingsExtensions.cs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using WindowsRuntime.ProjectionWriter.Generation; - -namespace WindowsRuntime.ProjectionWriter; - -/// -/// Extension methods for . -/// -internal static class SettingsExtensions -{ - extension(Settings settings) - { - /// - /// Gets the accessibility modifier ("public" or "internal") used for - /// generated types based on the and - /// flags. - /// - public string InternalAccessibility => settings.Internal || settings.Embedded ? "internal" : "public"; - } -} diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index 801d78d31..a6611bfa3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -46,7 +46,7 @@ public static void WriteAbiStruct(IndentedTextWriter writer, ProjectionEmitConte writer.WriteLine(isMultiline: true, $$""" {{marshallerOrTypeAttrs}} {{valueTypeAttr}} - {{context.Settings.InternalAccessibility}} unsafe struct {{nameStripped}} + {{(context.Settings.Internal ? "internal" : "public")}} unsafe struct {{nameStripped}} """); using (writer.WriteBlock()) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index d5696f63f..f67c41d93 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -292,7 +292,7 @@ public static void WriteStaticClass(IndentedTextWriter writer, ProjectionEmitCon writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} {{customAttrs}} - {{context.Settings.InternalAccessibility}} static class {{name}} + {{(context.Settings.Internal ? "internal" : "public")}} static class {{name}} """); using (writer.WriteBlock()) { diff --git a/src/WinRT.Projection.Writer/Generation/Settings.cs b/src/WinRT.Projection.Writer/Generation/Settings.cs index 402d906bc..e1c3924a7 100644 --- a/src/WinRT.Projection.Writer/Generation/Settings.cs +++ b/src/WinRT.Projection.Writer/Generation/Settings.cs @@ -107,11 +107,6 @@ public TypeFilter AdditionFilter /// public bool Internal { get; init; } - /// - /// Gets or sets a value indicating whether the projection is embedded into a consuming assembly (forces internal visibility). - /// - public bool Embedded { get; init; } - /// /// Gets or sets a value indicating whether projected enums are forced to public visibility (overrides ). /// diff --git a/src/WinRT.Projection.Writer/ProjectionWriter.cs b/src/WinRT.Projection.Writer/ProjectionWriter.cs index 53fc163ef..3d75cef69 100644 --- a/src/WinRT.Projection.Writer/ProjectionWriter.cs +++ b/src/WinRT.Projection.Writer/ProjectionWriter.cs @@ -48,7 +48,6 @@ public static void Run(ProjectionWriterOptions options) MaxDegreesOfParallelism = options.MaxDegreesOfParallelism, Component = options.Component, Internal = options.Internal, - Embedded = options.Embedded, PublicEnums = options.PublicEnums, PublicExclusiveTo = options.PublicExclusiveTo, IdicExclusiveTo = options.IdicExclusiveTo, diff --git a/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs b/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs index 9a03dc933..f89bdbf34 100644 --- a/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs +++ b/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs @@ -51,11 +51,6 @@ public sealed class ProjectionWriterOptions /// public bool Internal { get; init; } - /// - /// Generate an embedded projection. - /// - public bool Embedded { get; init; } - /// /// If true with embedded option, generate enums as public. /// From 8360660de844d81724fd94b8a70a5e2888771de3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 11:54:22 -0700 Subject: [PATCH 099/171] Remove CsWinRTEmbedded* leftover MSBuild properties Follow-up to the previous `Embedded` removal commit. Cleans up the remaining `CsWinRTEmbedded*`-prefixed MSBuild properties in `nuget/Microsoft.Windows.CsWinRT.targets` and the dead `PublicEnums` chain that they were feeding into. Removed MSBuild bits: - `` property declaration + its use in `CsWinRTParams` - `` property declaration + its use in `CsWinRTParams` - `PublicEnums="$(CsWinRTEmbeddedPublicEnums)"` attribute on the `RunCsWinRTProjectionRefGenerator` task invocation Removed the dead `PublicEnums` chain in the writer (it was declared at every layer but never actually consumed by any emission logic): - `Settings.PublicEnums` - `ProjectionWriterOptions.PublicEnums` - `ProjectionWriter.cs` propagation line - `RunCsWinRTProjectionRefGenerator.PublicEnums` + its response-file emission - `ReferenceProjectionGeneratorArgs.PublicEnums` + `--public-enums` CLI flag - `ReferenceProjectionGeneratorArgs.Parsing.cs` parser entry - `ReferenceProjectionGenerator.cs` propagation line Left untouched: `Microsoft.Windows.CsWinRT.Embedded.targets` -- it defines a separate feature (`CsWinRTEmbeddedSources*`, `CsWinRTEmbeddedTFMNet5OrGreater`) about copying the runtime sources into a consumer assembly, unrelated to the projection-mode `Embedded` flag that was removed. Validation: 763/763 byte-identical across pushnot/evwithui/windows scenarios; Writer, TestRunner, Ref.Generator, and Generator.Tasks all build with 0 warnings, 0 errors. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- nuget/Microsoft.Windows.CsWinRT.targets | 5 ----- .../RunCsWinRTProjectionRefGenerator.cs | 12 ------------ .../Generation/ReferenceProjectionGenerator.cs | 1 - .../ReferenceProjectionGeneratorArgs.Parsing.cs | 1 - .../Generation/ReferenceProjectionGeneratorArgs.cs | 7 ------- src/WinRT.Projection.Writer/Generation/Settings.cs | 5 ----- src/WinRT.Projection.Writer/ProjectionWriter.cs | 1 - .../ProjectionWriterOptions.cs | 5 ----- 8 files changed, 37 deletions(-) diff --git a/nuget/Microsoft.Windows.CsWinRT.targets b/nuget/Microsoft.Windows.CsWinRT.targets index b86ba5688..d679c4152 100644 --- a/nuget/Microsoft.Windows.CsWinRT.targets +++ b/nuget/Microsoft.Windows.CsWinRT.targets @@ -287,8 +287,6 @@ Copyright (C) Microsoft Corporation. All rights reserved. -internal - -embedded - -public_enums -public_exclusiveto -idic_exclusiveto -reference_projection @@ -301,8 +299,6 @@ $(CsWinRTWindowsMetadataInput) -output "$(CsWinRTGeneratedFilesDir.TrimEnd('\'))" $(CsWinRTFilters) $(CsWinRTIncludeWinRTInterop) -$(CsWinRTEmbeddedProjection) -$(CsWinRTEmbeddedEnums) $(CsWinRTPublicExclusiveTo) $(CsWinRTDynamicallyInterfaceCastableExclusiveTo) $(CsWinRTReferenceProjection) @@ -405,7 +401,6 @@ $(CsWinRTInternalProjection) ExcludeNamespaces="@(_CsWinRTRefExcludes)" Verbose="$(CsWinRTMessageImportance.Equals('high'))" Component="$(CsWinRTComponent)" - PublicEnums="$(CsWinRTEmbeddedPublicEnums)" PublicExclusiveTo="$(CsWinRTPublicExclusiveToInterfaces)" IdicExclusiveTo="$(CsWinRTDynamicallyInterfaceCastableExclusiveTo)" ReferenceProjection="$(CsWinRTGenerateReferenceProjection)" diff --git a/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs b/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs index d1e148bf8..139fc3a63 100644 --- a/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs +++ b/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs @@ -79,13 +79,6 @@ public sealed class RunCsWinRTProjectionRefGenerator : ToolTask /// public bool InternalProjection { get; set; } - /// - /// Gets or sets whether to emit enums as public when used with the embedded option. - /// Mirrors the C++ '-public_enums' arg. - /// CsWinRT 3.0 leftover; preserved for OLD-target parity. - /// - public bool PublicEnums { get; set; } - /// /// Gets or sets whether to make exclusive-to interfaces public in the projection /// (default is internal). Mirrors the C++ '-public_exclusiveto' arg. @@ -257,11 +250,6 @@ protected override string GenerateResponseFileCommands() AppendResponseFileCommand(args, "--internal", "true"); } - if (PublicEnums) - { - AppendResponseFileCommand(args, "--public-enums", "true"); - } - if (PublicExclusiveTo) { AppendResponseFileCommand(args, "--public-exclusive-to", "true"); diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs index 3d1a7ec86..cc0329827 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs @@ -104,7 +104,6 @@ private static ProjectionWriterOptions BuildWriterOptions(ReferenceProjectionGen Verbose = args.Verbose, Component = args.Component, Internal = args.Internal, - PublicEnums = args.PublicEnums, PublicExclusiveTo = args.PublicExclusiveTo, IdicExclusiveTo = args.IdicExclusiveTo, ReferenceProjection = args.ReferenceProjection, diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs index d4a70feaa..0f228ebce 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs @@ -88,7 +88,6 @@ public static ReferenceProjectionGeneratorArgs ParseFromResponseFile(string path Verbose = GetOptionalBoolArgument(argsMap, nameof(Verbose)), Component = GetOptionalBoolArgument(argsMap, nameof(Component)), Internal = GetOptionalBoolArgument(argsMap, nameof(Internal)), - PublicEnums = GetOptionalBoolArgument(argsMap, nameof(PublicEnums)), PublicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(PublicExclusiveTo)), IdicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(IdicExclusiveTo)), ReferenceProjection = GetOptionalBoolArgument(argsMap, nameof(ReferenceProjection)), diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs index fb5010c1d..c84700dd6 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs @@ -53,13 +53,6 @@ internal sealed partial class ReferenceProjectionGeneratorArgs [CommandLineArgumentName("--internal")] public bool Internal { get; init; } - /// - /// Gets whether to emit enums as public when used with the embedded option. - /// CsWinRT 3.0 leftover; preserved for OLD-target parity. - /// - [CommandLineArgumentName("--public-enums")] - public bool PublicEnums { get; init; } - /// Gets whether to make exclusive-to interfaces public in the projection. [CommandLineArgumentName("--public-exclusive-to")] public bool PublicExclusiveTo { get; init; } diff --git a/src/WinRT.Projection.Writer/Generation/Settings.cs b/src/WinRT.Projection.Writer/Generation/Settings.cs index e1c3924a7..1dede9039 100644 --- a/src/WinRT.Projection.Writer/Generation/Settings.cs +++ b/src/WinRT.Projection.Writer/Generation/Settings.cs @@ -107,11 +107,6 @@ public TypeFilter AdditionFilter /// public bool Internal { get; init; } - /// - /// Gets or sets a value indicating whether projected enums are forced to public visibility (overrides ). - /// - public bool PublicEnums { get; init; } - /// /// Gets or sets a value indicating whether [ExclusiveTo] interfaces are emitted as public rather than internal. /// diff --git a/src/WinRT.Projection.Writer/ProjectionWriter.cs b/src/WinRT.Projection.Writer/ProjectionWriter.cs index 3d75cef69..721ef8384 100644 --- a/src/WinRT.Projection.Writer/ProjectionWriter.cs +++ b/src/WinRT.Projection.Writer/ProjectionWriter.cs @@ -48,7 +48,6 @@ public static void Run(ProjectionWriterOptions options) MaxDegreesOfParallelism = options.MaxDegreesOfParallelism, Component = options.Component, Internal = options.Internal, - PublicEnums = options.PublicEnums, PublicExclusiveTo = options.PublicExclusiveTo, IdicExclusiveTo = options.IdicExclusiveTo, ReferenceProjection = options.ReferenceProjection, diff --git a/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs b/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs index f89bdbf34..df6471f74 100644 --- a/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs +++ b/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs @@ -51,11 +51,6 @@ public sealed class ProjectionWriterOptions /// public bool Internal { get; init; } - /// - /// If true with embedded option, generate enums as public. - /// - public bool PublicEnums { get; init; } - /// /// Make exclusive-to interfaces public in the projection (default is internal). /// From c8fc9647a599582dd609526cc8b9c50ee7318648 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 12:06:46 -0700 Subject: [PATCH 100/171] Remove Internal/private-projection support end-to-end In CsWinRT 3.0 private projections aren't supported anymore. Remove the `Internal` flag from the writer surface and the entire MSBuild "private projection" parallel flow that fed it. Hardcode `public` visibility everywhere instead of the ternary. **Writer source (5 call sites simplified to hardcoded public):** - `ProjectionFileBuilder.cs`: enum forward-declaration + enum body + delegate decl + attribute class decl (3 multiline templates + 1 single-line) - `ClassFactory.cs`: static-class wrapper for static interfaces + runtime class declaration (removed the temporary `string accessibility` local) - `AbiStructFactory.cs`: ABI struct declaration **Removed type/option members:** - `Settings.Internal` (Generation/Settings.cs) - `ProjectionWriterOptions.Internal` (public API option) - `ProjectionWriter.cs`: `Internal = options.Internal,` propagation - `ReferenceProjectionGeneratorArgs.Internal` + `--internal` CLI flag - `ReferenceProjectionGeneratorArgs.Parsing.cs`: `Internal` parse entry - `ReferenceProjectionGenerator.cs`: `Internal = args.Internal,` propagation - `RunCsWinRTProjectionRefGenerator.InternalProjection` MSBuild task property + the `--internal` response-file emission - TestRunner: `internalMode` local, the `--internal` rsp switch, and the `Internal =` option pass-through **MSBuild .targets cleanup** (`Microsoft.Windows.CsWinRT.targets`): - `CsWinRTResponseFilePrivateProjection` / `CsWinRTCommandPrivateProjection` - `CsWinRTExcludesPrivate` / `CsWinRTIncludesPrivate` defaults and the `CsWinRTExcludePrivateItems` / `CsWinRTIncludePrivateItems` ItemGroup - `CsWinRTPrivateFilters` PropertyGroup - `CsWinRTPrivateIncludeWinRTInterop` PropertyGroup - `CsWinRTInternalProjection` property + its use in `CsWinRTPrivateParams` - `CsWinRTPrivateParams` PropertyGroup and its `WriteLinesToFile` to `cswinrt_internal.rsp` - `CsWinRTPrivateProjectionExitCode` declaration and the corresponding `CallTarget` exit-code disjunction - The mirrored `_CsWinRTRefPrivate*` filter/include/exclude parsing ItemGroup - The `_CsWinRTRefPrivateHasWindows` WindowsRuntime.Internal auto-include - The mirrored `_CsWinRTRefPrivateInputs` ItemGroup - The second `RunCsWinRTProjectionRefGenerator` task invocation (`InternalProjection="true"`, gated on `CsWinRTPrivateProjection` == 'true') - The `cswinrtprojectionrefgen (private projection):` Message - The leading `cswinrtprojectionrefgen (public projection):` Message was simplified to just `cswinrtprojectionrefgen:` since there's only one flow now **Docs cleanup:** - Deleted `docs/private-projection.md` (a 2.x-only feature doc that already had a "not updated for 3.0" warning at the top) - Removed the `private-projection.md` reference from `src/cswinrt.slnx` Validation: 763/763 byte-identical against the fresh baselines from two commits ago across pushnot/evwithui/windows scenarios; all four projects (Writer, TestRunner, Ref.Generator, Generator.Tasks) build with 0 warnings, 0 errors. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- docs/private-projection.md | 19 ----- nuget/Microsoft.Windows.CsWinRT.targets | 77 ++----------------- .../RunCsWinRTProjectionRefGenerator.cs | 11 --- .../ReferenceProjectionGenerator.cs | 1 - ...eferenceProjectionGeneratorArgs.Parsing.cs | 1 - .../ReferenceProjectionGeneratorArgs.cs | 7 -- .../Program.cs | 5 +- .../Builders/ProjectionFileBuilder.cs | 9 +-- .../Factories/AbiStructFactory.cs | 2 +- .../Factories/ClassFactory.cs | 5 +- .../Generation/Settings.cs | 5 -- .../ProjectionWriter.cs | 1 - .../ProjectionWriterOptions.cs | 5 -- src/cswinrt.slnx | 1 - 14 files changed, 14 insertions(+), 135 deletions(-) delete mode 100644 docs/private-projection.md diff --git a/docs/private-projection.md b/docs/private-projection.md deleted file mode 100644 index 2339944ed..000000000 --- a/docs/private-projection.md +++ /dev/null @@ -1,19 +0,0 @@ -# Private Projection Support - -> **⚠️ This document has not been updated for CsWinRT 3.0.** Private projection support is a CsWinRT 2.x feature. Its status in CsWinRT 3.0 has not been determined yet. - -## Overview - -Support for private projections is an option on the C#/WinRT tool that allows for projections to be generated with accessibility scoped to the module generating the projection. - -## How-To - -The process is nearly identical to how you generate a projection today. The difference is a new set of build properties that look similar to the properties used to generate projections globally. -First you must set a property `CsWinRTPrivateProjection` to `true`. Then specify your includes/excludes using `CsWinRTIncludesPrivate` and `CsWinRTExcludesPrivate`. - -## Notes - -Note that this means projected types are not accessible outside the module. - -You can generate part of your projection as global and part as private, but you must take care to keep the types disjoint otherwise you will generate duplicates of the types projected as both. -Similarly, an app can't reference two libraries that both make the same private projection -- this is an ambiguity issue because types of the same name exist in different assemblies. diff --git a/nuget/Microsoft.Windows.CsWinRT.targets b/nuget/Microsoft.Windows.CsWinRT.targets index d679c4152..e199ab83f 100644 --- a/nuget/Microsoft.Windows.CsWinRT.targets +++ b/nuget/Microsoft.Windows.CsWinRT.targets @@ -230,12 +230,10 @@ Copyright (C) Microsoft Corporation. All rights reserved. $(CsWinRTGeneratedFilesDir)cswinrt.rsp - $(CsWinRTGeneratedFilesDir)cswinrt_internal.rsp "$(CsWinRTExe)" %40"$(CsWinRTResponseFile)" - "$(CsWinRTExe)" %40"$(CsWinRTResponseFilePrivateProjection)" -input $(CsWinRTWindowsMetadata) @@ -249,26 +247,14 @@ Copyright (C) Microsoft Corporation. All rights reserved. Windows;Microsoft - Windows;Microsoft - - - - - - - -@(CsWinRTExcludePrivateItems->'-exclude %(Identity)', ' ') -@(CsWinRTIncludePrivateItems->'-include %(Identity)', ' ') - - @(CsWinRTExcludeItems->'-exclude %(Identity)', ' ') @(CsWinRTIncludeItems->'-include %(Identity)', ' ') @@ -280,13 +266,6 @@ Copyright (C) Microsoft Corporation. All rights reserved. -include WindowsRuntime.Internal - - --input $(CsWinRTInteropMetadata) --include WindowsRuntime.Internal - - - -internal -public_exclusiveto -idic_exclusiveto -reference_projection @@ -303,17 +282,6 @@ $(CsWinRTPublicExclusiveTo) $(CsWinRTDynamicallyInterfaceCastableExclusiveTo) $(CsWinRTReferenceProjection) - - -$(CsWinRTCommandVerbosity) --target $(CsWinRTExeTFM) -$(CsWinRTWindowsMetadataInput) --input @(CsWinRTInputs->'"%(FullPath)"', ' ') --output "$(CsWinRTGeneratedFilesDir.TrimEnd('\'))" -$(CsWinRTPrivateFilters) -$(CsWinRTPrivateIncludeWinRTInterop) -$(CsWinRTInternalProjection) - <_CsWinRTRefFilterLines Include="$([System.Text.RegularExpressions.Regex]::Split('$(CsWinRTFilters)', '[\r\n]+'))" /> - <_CsWinRTRefPrivateFilterLines Include="$([System.Text.RegularExpressions.Regex]::Split('$(CsWinRTPrivateFilters)', '[\r\n]+'))" /> <_CsWinRTRefIncludes Include="$([System.String]::Copy('%(_CsWinRTRefFilterLines.Identity)').Trim().Substring(9))" Condition="$([System.String]::Copy('%(_CsWinRTRefFilterLines.Identity)').Trim().StartsWith('-include '))" /> <_CsWinRTRefExcludes Include="$([System.String]::Copy('%(_CsWinRTRefFilterLines.Identity)').Trim().Substring(9))" Condition="$([System.String]::Copy('%(_CsWinRTRefFilterLines.Identity)').Trim().StartsWith('-exclude '))" /> - - <_CsWinRTRefPrivateIncludes Include="$([System.String]::Copy('%(_CsWinRTRefPrivateFilterLines.Identity)').Trim().Substring(9))" - Condition="$([System.String]::Copy('%(_CsWinRTRefPrivateFilterLines.Identity)').Trim().StartsWith('-include '))" /> - <_CsWinRTRefPrivateExcludes Include="$([System.String]::Copy('%(_CsWinRTRefPrivateFilterLines.Identity)').Trim().Substring(9))" - Condition="$([System.String]::Copy('%(_CsWinRTRefPrivateFilterLines.Identity)').Trim().StartsWith('-exclude '))" /> <_CsWinRTRefHasWindows Include="@(_CsWinRTRefIncludes)" Condition="'%(Identity)' == 'Windows'" /> - <_CsWinRTRefPrivateHasWindows Include="@(_CsWinRTRefPrivateIncludes)" Condition="'%(Identity)' == 'Windows'" /> <_CsWinRTRefIncludes Include="WindowsRuntime.Internal" /> <_CsWinRTRefInteropInputs Include="$(CsWinRTInteropMetadata)" /> - - <_CsWinRTRefPrivateIncludes Include="WindowsRuntime.Internal" /> - <_CsWinRTRefPrivateInteropInputs Include="$(CsWinRTInteropMetadata)" /> - <_CsWinRTRefInputs Include="@(CsWinRTInputs->'%(FullPath)')" /> <_CsWinRTRefInputs Include="$(CsWinRTWindowsMetadata)" Condition="'$(CsWinRTWindowsMetadata)' != ''" /> <_CsWinRTRefInputs Include="@(_CsWinRTRefInteropInputs)" /> - - <_CsWinRTRefPrivateInputs Include="@(CsWinRTInputs->'%(FullPath)')" /> - <_CsWinRTRefPrivateInputs Include="$(CsWinRTWindowsMetadata)" Condition="'$(CsWinRTWindowsMetadata)' != ''" /> - <_CsWinRTRefPrivateInputs Include="@(_CsWinRTRefPrivateInteropInputs)" /> - + - - - - - @@ -434,7 +367,7 @@ $(CsWinRTInternalProjection) - + diff --git a/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs b/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs index 139fc3a63..dd47ab8a0 100644 --- a/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs +++ b/src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs @@ -73,12 +73,6 @@ public sealed class RunCsWinRTProjectionRefGenerator : ToolTask /// public bool Component { get; set; } - /// - /// Gets or sets whether to generate a private (internal) projection. Mirrors the C++ '-internal' arg. - /// CsWinRT 3.0 leftover; preserved for OLD-target parity. - /// - public bool InternalProjection { get; set; } - /// /// Gets or sets whether to make exclusive-to interfaces public in the projection /// (default is internal). Mirrors the C++ '-public_exclusiveto' arg. @@ -245,11 +239,6 @@ protected override string GenerateResponseFileCommands() AppendResponseFileCommand(args, "--component", "true"); } - if (InternalProjection) - { - AppendResponseFileCommand(args, "--internal", "true"); - } - if (PublicExclusiveTo) { AppendResponseFileCommand(args, "--public-exclusive-to", "true"); diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs index cc0329827..52b1e960a 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs @@ -103,7 +103,6 @@ private static ProjectionWriterOptions BuildWriterOptions(ReferenceProjectionGen AdditionExclude = args.AdditionExcludeNamespaces, Verbose = args.Verbose, Component = args.Component, - Internal = args.Internal, PublicExclusiveTo = args.PublicExclusiveTo, IdicExclusiveTo = args.IdicExclusiveTo, ReferenceProjection = args.ReferenceProjection, diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs index 0f228ebce..da06dbfa5 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs @@ -87,7 +87,6 @@ public static ReferenceProjectionGeneratorArgs ParseFromResponseFile(string path AdditionExcludeNamespaces = GetOptionalStringArrayArgument(argsMap, nameof(AdditionExcludeNamespaces)), Verbose = GetOptionalBoolArgument(argsMap, nameof(Verbose)), Component = GetOptionalBoolArgument(argsMap, nameof(Component)), - Internal = GetOptionalBoolArgument(argsMap, nameof(Internal)), PublicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(PublicExclusiveTo)), IdicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(IdicExclusiveTo)), ReferenceProjection = GetOptionalBoolArgument(argsMap, nameof(ReferenceProjection)), diff --git a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs index c84700dd6..c6a2b787c 100644 --- a/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs +++ b/src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs @@ -46,13 +46,6 @@ internal sealed partial class ReferenceProjectionGeneratorArgs [CommandLineArgumentName("--component")] public bool Component { get; init; } - /// - /// Gets whether to generate a private (internal) projection. - /// CsWinRT 3.0 leftover; preserved for OLD-target parity. - /// - [CommandLineArgumentName("--internal")] - public bool Internal { get; init; } - /// Gets whether to make exclusive-to interfaces public in the projection. [CommandLineArgumentName("--public-exclusive-to")] public bool PublicExclusiveTo { get; init; } diff --git a/src/WinRT.Projection.Writer.TestRunner/Program.cs b/src/WinRT.Projection.Writer.TestRunner/Program.cs index 319f81edc..4b7c0efc0 100644 --- a/src/WinRT.Projection.Writer.TestRunner/Program.cs +++ b/src/WinRT.Projection.Writer.TestRunner/Program.cs @@ -61,7 +61,7 @@ private static int RunRsp(string rspPath, bool refMode) var include = new System.Collections.Generic.List(); var exclude = new System.Collections.Generic.List(); string? outputFolder = null; - bool component = false, internalMode = false; + bool component = false; int maxDegreesOfParallelism = -1; var tokens = new System.Collections.Generic.List(); foreach (string raw in text.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries)) @@ -87,7 +87,6 @@ private static int RunRsp(string rspPath, bool refMode) case "--exclude-namespaces": case "--exclude": if (next is not null) { exclude.AddRange(next.Split(',', StringSplitOptions.RemoveEmptyEntries)); i++; } break; case "--component": component = true; break; - case "--internal": internalMode = true; break; case "--reference-projection": refMode = true; break; case "--max-degrees-of-parallelism": case "--mdop": if (next is not null && int.TryParse(next, out int mdop)) { maxDegreesOfParallelism = mdop; i++; } break; @@ -103,7 +102,7 @@ private static int RunRsp(string rspPath, bool refMode) { InputPaths = inputs, OutputFolder = outputFolder, Include = include, Exclude = exclude, - Component = component, Internal = internalMode, + Component = component, ReferenceProjection = refMode, Verbose = false, MaxDegreesOfParallelism = maxDegreesOfParallelism, }); diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 5397cd7d4..8c68407f0 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -93,7 +93,6 @@ private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext c bool isFlags = TypeCategorization.IsFlagsEnum(type); string enumUnderlyingType = isFlags ? "uint" : "int"; - string accessibility = context.Settings.Internal ? "internal" : "public"; string typeName = type.Name?.Value ?? string.Empty; WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); @@ -110,7 +109,7 @@ private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext c {{customAttrs}} {{comWrappersAttr}} {{refTypeAttr}} - {{accessibility}} enum {{typeName}} : {{enumUnderlyingType}} + public enum {{typeName}} : {{enumUnderlyingType}} """); using (writer.WriteBlock()) @@ -302,7 +301,7 @@ private static void WriteContract(IndentedTextWriter writer, ProjectionEmitConte CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); - writer.WriteLine($"{(context.Settings.Internal ? "internal" : "public")} enum {typeName};"); + writer.WriteLine($"public enum {typeName};"); } /// @@ -339,7 +338,7 @@ private static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitConte {{customAttrs}} {{comWrappersAttr}} {{guidAttr}} - {{(context.Settings.Internal ? "internal" : "public")}} delegate {{ret}} {{typedefName}}{{typeParams}}({{parms}}); + public delegate {{ret}} {{typedefName}}{{typeParams}}({{parms}}); """); } @@ -357,7 +356,7 @@ private static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitCont writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} {{customAttrs}} - {{(context.Settings.Internal ? "internal" : "public")}} sealed class {{typeName}} : Attribute + public sealed class {{typeName}} : Attribute """); using (writer.WriteBlock()) diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index a6611bfa3..04457ad0b 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -46,7 +46,7 @@ public static void WriteAbiStruct(IndentedTextWriter writer, ProjectionEmitConte writer.WriteLine(isMultiline: true, $$""" {{marshallerOrTypeAttrs}} {{valueTypeAttr}} - {{(context.Settings.Internal ? "internal" : "public")}} unsafe struct {{nameStripped}} + public unsafe struct {{nameStripped}} """); using (writer.WriteBlock()) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index f67c41d93..d421ad3a9 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -292,7 +292,7 @@ public static void WriteStaticClass(IndentedTextWriter writer, ProjectionEmitCon writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} {{customAttrs}} - {{(context.Settings.Internal ? "internal" : "public")}} static class {{name}} + public static class {{name}} """); using (writer.WriteBlock()) { @@ -573,7 +573,6 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); - string accessibility = context.Settings.Internal ? "internal" : "public"; // are emitted as plain (non-partial) classes. string modifiers = TypeCategorization.IsStatic(type) ? "static " : type.IsSealed ? "sealed " : ""; WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); @@ -583,7 +582,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont {{metadataAttr}} {{customAttrs}} {{comWrappersAttr}} - {{accessibility}} {{modifiers}}class {{name}}{{inheritance}} + public {{modifiers}}class {{name}}{{inheritance}} """); using IndentedTextWriter.Block __classBlock = writer.WriteBlock(); diff --git a/src/WinRT.Projection.Writer/Generation/Settings.cs b/src/WinRT.Projection.Writer/Generation/Settings.cs index 1dede9039..fe24269ef 100644 --- a/src/WinRT.Projection.Writer/Generation/Settings.cs +++ b/src/WinRT.Projection.Writer/Generation/Settings.cs @@ -102,11 +102,6 @@ public TypeFilter AdditionFilter /// public bool Component { get; init; } - /// - /// Gets or sets a value indicating whether projected types are emitted as internal rather than public. - /// - public bool Internal { get; init; } - /// /// Gets or sets a value indicating whether [ExclusiveTo] interfaces are emitted as public rather than internal. /// diff --git a/src/WinRT.Projection.Writer/ProjectionWriter.cs b/src/WinRT.Projection.Writer/ProjectionWriter.cs index 721ef8384..943dafdee 100644 --- a/src/WinRT.Projection.Writer/ProjectionWriter.cs +++ b/src/WinRT.Projection.Writer/ProjectionWriter.cs @@ -47,7 +47,6 @@ public static void Run(ProjectionWriterOptions options) Logger = options.Logger, MaxDegreesOfParallelism = options.MaxDegreesOfParallelism, Component = options.Component, - Internal = options.Internal, PublicExclusiveTo = options.PublicExclusiveTo, IdicExclusiveTo = options.IdicExclusiveTo, ReferenceProjection = options.ReferenceProjection, diff --git a/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs b/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs index df6471f74..7f1333376 100644 --- a/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs +++ b/src/WinRT.Projection.Writer/ProjectionWriterOptions.cs @@ -46,11 +46,6 @@ public sealed class ProjectionWriterOptions /// public bool Component { get; init; } - /// - /// Generate an internal (non-public) projection. - /// - public bool Internal { get; init; } - /// /// Make exclusive-to interfaces public in the projection (default is internal). /// diff --git a/src/cswinrt.slnx b/src/cswinrt.slnx index cbc53422e..8416f9f3e 100644 --- a/src/cswinrt.slnx +++ b/src/cswinrt.slnx @@ -32,7 +32,6 @@ - From a6d5d45b7cba532dc2c461bca4bb650dd7d44f1e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 13:11:40 -0700 Subject: [PATCH 101/171] Refine platform scope and keyword initialization Minor cleanups and refactors across the projection writer: - ProjectionFileBuilder: adjust inline comment to quote the '[SupportedOSPlatform]' attribute name for clarity. - ProjectionEmitContext: use target-typed `new(...)` when returning PlatformSuppressionScope and make the scope's constructor public; also apply small whitespace/ordering cleanup when restoring context state. - CSharpKeywords: add XML documentation and switch the Keywords initialization to the new collection literal style (replacing the previous array + ToFrozenSet() pattern) for clarity and brevity. --- .../Builders/ProjectionFileBuilder.cs | 2 +- .../Generation/ProjectionEmitContext.cs | 7 +++++-- src/WinRT.Projection.Writer/Helpers/CSharpKeywords.cs | 9 ++++++--- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 8c68407f0..05bc803fe 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -124,7 +124,7 @@ public enum {{typeName}} : {{enumUnderlyingType}} string fieldName = field.Name?.Value ?? string.Empty; string constantValue = field.Constant.FormatLiteral(); - // Emits per-enum-field [SupportedOSPlatform] when the field has a [ContractVersion]. + // Emits per-enum-field '[SupportedOSPlatform]' when the field has a '[ContractVersion]' CustomAttributeFactory.WritePlatformAttribute(writer, context, field); writer.WriteLine($"{fieldName} = unchecked(({enumUnderlyingType}){constantValue}),"); diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs b/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs index 36330867e..ce634c74b 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs @@ -94,9 +94,11 @@ public PlatformSuppressionScope EnterPlatformSuppressionScope(string platform) { bool prevCheck = CheckPlatform; string prevPlatform = Platform; + CheckPlatform = true; Platform = platform; - return new PlatformSuppressionScope(this, prevCheck, prevPlatform); + + return new(this, prevCheck, prevPlatform); } /// @@ -108,7 +110,7 @@ public PlatformSuppressionScope EnterPlatformSuppressionScope(string platform) private readonly bool _prevCheck; private readonly string _prevPlatform; - internal PlatformSuppressionScope(ProjectionEmitContext context, bool prevCheck, string prevPlatform) + public PlatformSuppressionScope(ProjectionEmitContext context, bool prevCheck, string prevPlatform) { _context = context; _prevCheck = prevCheck; @@ -124,6 +126,7 @@ public void Dispose() { context.CheckPlatform = _prevCheck; context.Platform = _prevPlatform; + _context = null; } } diff --git a/src/WinRT.Projection.Writer/Helpers/CSharpKeywords.cs b/src/WinRT.Projection.Writer/Helpers/CSharpKeywords.cs index b03e9ca4f..53eacb95d 100644 --- a/src/WinRT.Projection.Writer/Helpers/CSharpKeywords.cs +++ b/src/WinRT.Projection.Writer/Helpers/CSharpKeywords.cs @@ -10,8 +10,11 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; /// internal static class CSharpKeywords { - private static readonly FrozenSet Keywords = new[] - { + /// + /// The set of well-known C# keywords. + /// + private static readonly FrozenSet Keywords = + [ "abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const", "continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit", "extern", "false", "finally", "fixed", "float", "for", "foreach", "goto", "if", "implicit", "in", "int", "interface", "internal", "is", "lock", "long", @@ -19,7 +22,7 @@ internal static class CSharpKeywords "readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc", "static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort", "using", "virtual", "void", "volatile", "while" - }.ToFrozenSet(); + ]; /// /// Returns whether is a reserved C# language keyword. From e1e0ac146b780ffdda4b91d9979f7a8f3daa1a5d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 13:29:25 -0700 Subject: [PATCH 102/171] Extract signature generation into SignatureGenerator `IidExpressionGenerator` mixed two concerns: (1) emitting WinRT GUID/IID expressions from stored `[Guid]` attribute bytes, and (2) emitting the parametric type signature string used as input to the WinRT GUID hash algorithm for generic instantiations. Split (2) into a new `SignatureGenerator` so the responsibilities are visible at the type level. **Moved to `SignatureGenerator`:** - `GetFundamentalTypeGuidSignature(FundamentalType)`: returns the signature code for a fundamental WinRT type (e.g. `i4`, `string`). - `WriteGuidSignature(IndentedTextWriter, ProjectionEmitContext, TypeSemantics)`: emits the parametric signature for the given type semantics. - `WriteGuidSignature(ProjectionEmitContext, TypeSemantics)`: convenience overload returning the signature as a string. - `WriteGuidSignatureForType(...)`: private dispatch by `TypeCategory` (enum / struct / delegate / interface / runtime-class). The new type calls back into `IidExpressionGenerator.WriteGuid` (the canonical hyphenated GUID form) which remains the rightful owner of the `[Guid]`-attribute-reading concern. **Stays in `IidExpressionGenerator`:** - `EscapeTypeNameForIdentifier`, `GetGuidFields`, `WriteGuid`, `FormatGuid`, `WriteGuidBytes` + `WriteByte`, `WriteIidGuidPropertyName` / `WriteIidReferenceGuidPropertyName`, `WriteIidGuidPropertyFromType`, `WriteIidGuidPropertyFromSignature` (now calls `SignatureGenerator.WriteGuidSignature`), `WriteIidGuidPropertyForClassInterfaces`, and the `InterfaceIIDs` file header/footer emitters. **Doc cleanup along the way:** - Removed a duplicate `` block on `WriteGuid` (had two identical summary tags). - Added missing `` docs to `WriteGuid`, `WriteGuidBytes`, `WriteByte`, `WriteIidGuidPropertyFromType`, `WriteIidGuidPropertyFromSignature`, and all the moved `SignatureGenerator` methods. - Refined the `IidExpressionGenerator` type summary to reflect the narrower responsibility, with a `` cross-reference to `SignatureGenerator`. Validation: 763/763 byte-identical across all three scenarios; build 0/0. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Helpers/IidExpressionGenerator.cs | 239 +++--------------- .../Helpers/SignatureGenerator.cs | 236 +++++++++++++++++ 2 files changed, 276 insertions(+), 199 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 5e218a1db..3634b3b40 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -17,33 +17,18 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; /// -/// Helpers for emitting WinRT GUID / IID expressions: signature characters for the GUID -/// hash algorithm, the canonical hyphenated string form of a type's [Guid], and the -/// byte-list form used when initializing native IID storage. +/// Helpers for emitting WinRT GUID / IID expressions: the canonical hyphenated string form of a +/// type's [Guid], the byte-list form used when initializing native IID storage, and +/// the IID_X / IID_XReference property emissions on the generated InterfaceIIDs +/// static class. /// +/// +/// The WinRT parametric signature generation that drives the IID hash for generic instances +/// lives in ; +/// is the only consumer of it from this file. +/// internal static partial class IidExpressionGenerator { - /// - /// Returns the GUID-signature character code for a fundamental WinRT type. - /// - public static string GetFundamentalTypeGuidSignature(FundamentalType t) => t switch - { - FundamentalType.Boolean => "b1", - FundamentalType.Char => "c2", - FundamentalType.Int8 => "i1", - FundamentalType.UInt8 => "u1", - FundamentalType.Int16 => "i2", - FundamentalType.UInt16 => "u2", - FundamentalType.Int32 => "i4", - FundamentalType.UInt32 => "u4", - FundamentalType.Int64 => "i8", - FundamentalType.UInt64 => "u8", - FundamentalType.Float => "f4", - FundamentalType.Double => "f8", - FundamentalType.String => "string", - _ => throw WellKnownProjectionWriterExceptions.UnknownFundamentalType() - }; - [GeneratedRegex(@"[ :<>`,.]")] private static partial Regex TypeNameEscapeRegex(); @@ -119,11 +104,12 @@ public static (uint Data1, ushort Data2, ushort Data3, byte[] Data4)? GetGuidFie } /// - /// Writes the GUID for in canonical hyphenated string form. - /// - /// - /// Writes the GUID for in canonical hyphenated string form. + /// Writes the GUID for in canonical hyphenated string form + /// (e.g. 00000000-0000-0000-0000-000000000000). /// + /// The writer to emit to. + /// The type whose [Guid] attribute is read. + /// When , hex digits are lower-case; otherwise upper-case. public static void WriteGuid(IndentedTextWriter writer, TypeDefinition type, bool lowerCase) { (uint data1, ushort data2, ushort data3, byte[] data4) = GetGuidFields(type) ?? throw WellKnownProjectionWriterExceptions.MissingGuidAttribute($"{type.Namespace}.{type.Name}"); @@ -154,8 +140,12 @@ public static string FormatGuid(TypeDefinition type, bool lowerCase) } /// - /// Writes the GUID bytes for as a hex byte list. + /// Writes the GUID bytes for as a hex byte list (e.g. + /// 0x00, 0x00, ..., 0x00), formatted for embedding inside a C# collection + /// expression that initializes a ReadOnlySpan<byte>. /// + /// The writer to emit to. + /// The type whose [Guid] attribute is read. public static void WriteGuidBytes(IndentedTextWriter writer, TypeDefinition type) { (uint data1, ushort data2, ushort data3, byte[] data4) = GetGuidFields(type) ?? throw WellKnownProjectionWriterExceptions.MissingGuidAttribute($"{type.Namespace}.{type.Name}"); @@ -173,6 +163,13 @@ public static void WriteGuidBytes(IndentedTextWriter writer, TypeDefinition type WriteByte(writer, data4[i], false); } } + + /// + /// Writes a single byte as 0xXX (or , 0xXX when not the first byte in a list). + /// + /// The writer to emit to. + /// The byte value (only the low 8 bits are used). + /// When , omits the leading ", " separator. private static void WriteByte(IndentedTextWriter writer, uint b, bool first) { writer.WriteIf(!first, ", "); @@ -199,8 +196,14 @@ public static void WriteIidReferenceGuidPropertyName(IndentedTextWriter writer, } /// - /// Writes a static IID property whose body is built from the [Guid] attribute bytes. + /// Writes a static IID property whose body is built from the [Guid] attribute bytes + /// of . The property is named IID_X (see + /// ) and returns a ref readonly Guid backed by + /// a stack-allocated ReadOnlySpan<byte>. /// + /// The writer to emit to. + /// The active emit context. + /// The type whose [Guid] attribute is read. public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { writer.Write("public static ref readonly Guid "); @@ -227,179 +230,17 @@ public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, Proje } /// - /// Writes the WinRT GUID parametric signature string for a type semantics. - /// - public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitContext context, TypeSemantics semantics) - { - switch (semantics) - { - case TypeSemantics.GuidType: - writer.Write("g16"); - break; - case TypeSemantics.ObjectType: - writer.Write("cinterface(IInspectable)"); - break; - case TypeSemantics.Fundamental f: - writer.Write(GetFundamentalTypeGuidSignature(f.Type)); - break; - case TypeSemantics.Definition d: - WriteGuidSignatureForType(writer, context, d.Type); - break; - case TypeSemantics.Reference r: - { - // Resolve the reference to a TypeDefinition (cross-module struct field, etc.). - (string ns, string name) = r.Type.Names(); - TypeDefinition? resolved = null; - - if (context.Cache is not null) - { - resolved = r.Type.TryResolve(context.Cache.RuntimeContext) - ?? context.Cache.Find(ns, name); - } - - if (resolved is not null) - { - WriteGuidSignatureForType(writer, context, resolved); - } - } - break; - case TypeSemantics.GenericInstance gi: - writer.Write("pinterface({"); - WriteGuid(writer, gi.GenericType, true); - writer.Write("};"); - for (int i = 0; i < gi.GenericArgs.Count; i++) - { - writer.WriteIf(i > 0, ";"); - - WriteGuidSignature(writer, context, gi.GenericArgs[i]); - } - writer.Write(")"); - break; - case TypeSemantics.GenericInstanceRef gir: - { - // Cross-module generic instance (e.g. Windows.Foundation.IReference - // appearing as a struct field). Resolve the generic type to a TypeDefinition - // so we can extract its [Guid]; recurse on each type argument. - (string ns, string name) = gir.GenericType.Names(); - TypeDefinition? resolved = null; - - if (context.Cache is not null) - { - resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) - ?? context.Cache.Find(ns, name); - } - - if (resolved is not null) - { - writer.Write("pinterface({"); - WriteGuid(writer, resolved, true); - writer.Write("};"); - for (int i = 0; i < gir.GenericArgs.Count; i++) - { - writer.WriteIf(i > 0, ";"); - - WriteGuidSignature(writer, context, gir.GenericArgs[i]); - } - writer.Write(")"); - } - } - break; - } - } - - /// - /// Convenience overload of - /// that leases an from , - /// emits the GUID signature into it, and returns the resulting string. + /// Writes a static IID property whose body is built from the parametric GUID signature + /// (computed via + /// for the type, then wrapped in the Windows.Foundation.IReference<T> + /// pinterface to produce the IID_XReference hashed GUID). /// + /// The writer to emit to. /// The active emit context. - /// The type semantics whose GUID signature is emitted. - /// The emitted GUID signature. - public static string WriteGuidSignature(ProjectionEmitContext context, TypeSemantics semantics) - { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteGuidSignature(writer, context, semantics); - return writer.ToString(); - } - - private static void WriteGuidSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) - { - TypeCategory cat = TypeCategorization.GetCategory(type); - switch (cat) - { - case TypeCategory.Enum: - writer.Write("enum("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(";"); - writer.Write(TypeCategorization.IsFlagsEnum(type) ? "u4" : "i4"); - writer.Write(")"); - break; - case TypeCategory.Struct: - writer.Write("struct("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(";"); - bool first = true; - foreach (FieldDefinition field in type.Fields) - { - if (field.IsStatic) - { - continue; - } - - if (field.Signature is null) - { - continue; - } - - writer.WriteIf(!first, ";"); - - first = false; - WriteGuidSignature(writer, context, TypeSemanticsFactory.Get(field.Signature.FieldType)); - } - writer.Write(")"); - break; - case TypeCategory.Delegate: - writer.Write("delegate({"); - WriteGuid(writer, type, true); - writer.Write("})"); - break; - case TypeCategory.Interface: - writer.Write("{"); - WriteGuid(writer, type, true); - writer.Write("}"); - break; - case TypeCategory.Class: - ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); - - if (defaultIface is TypeDefinition di) - { - writer.Write("rc("); - TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); - TypedefNameWriter.WriteTypeParams(writer, type); - writer.Write(";"); - WriteGuidSignature(writer, context, new TypeSemantics.Definition(di)); - writer.Write(")"); - } - else - { - writer.Write("{"); - WriteGuid(writer, type, true); - writer.Write("}"); - } - - break; - } - } - - /// - /// Writes a static IID property whose body is built from the parametric GUID signature. - /// + /// The type whose IReference<T> IID is emitted. public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string guidSig = WriteGuidSignature(context, new TypeSemantics.Definition(type)); + string guidSig = SignatureGenerator.WriteGuidSignature(context, new TypeSemantics.Definition(type)); string ireferenceGuidSig = "pinterface({61c17706-2d65-11e0-9ae8-d48564015472};" + guidSig + ")"; Guid guidValue = GuidGenerator.Generate(ireferenceGuidSig); byte[] bytes = guidValue.ToByteArray(); diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs new file mode 100644 index 000000000..a793bafd6 --- /dev/null +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -0,0 +1,236 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Errors; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Helpers; + +/// +/// Emits the WinRT parametric type signature string used as the input to the WinRT GUID hash +/// algorithm. The signature format mirrors the cswinrt.exe C++ implementation: +/// +/// Fundamental types map to a single-character code (e.g. i4, u8, string). +/// Enums become enum(<name>;<underlying>). +/// Structs become struct(<name>;<field-signatures>). +/// Delegates become delegate({<guid>}). +/// Interfaces become {<guid>}. +/// Runtime classes become rc(<name>;<default-interface-signature>). +/// Generic instantiations become pinterface({<open-guid>};<arg-signatures>). +/// +/// +internal static class SignatureGenerator +{ + /// + /// Returns the GUID-signature character code for a fundamental WinRT type (e.g. i4 + /// for , string for ). + /// + /// The fundamental type. + /// The signature code. + /// Thrown when + /// is not a known fundamental type. + public static string GetFundamentalTypeGuidSignature(FundamentalType type) => type switch + { + FundamentalType.Boolean => "b1", + FundamentalType.Char => "c2", + FundamentalType.Int8 => "i1", + FundamentalType.UInt8 => "u1", + FundamentalType.Int16 => "i2", + FundamentalType.UInt16 => "u2", + FundamentalType.Int32 => "i4", + FundamentalType.UInt32 => "u4", + FundamentalType.Int64 => "i8", + FundamentalType.UInt64 => "u8", + FundamentalType.Float => "f4", + FundamentalType.Double => "f8", + FundamentalType.String => "string", + _ => throw WellKnownProjectionWriterExceptions.UnknownFundamentalType() + }; + + /// + /// Writes the WinRT GUID parametric signature for into + /// . Used as input to GuidGenerator.Generate to compute the + /// IID for a generic interface instantiation, or as the inner signature of a containing + /// composite (struct field, runtime-class default interface, etc.). + /// + /// The writer to emit to. + /// The active emit context (used for cross-module type resolution). + /// The type semantics whose signature is emitted. + public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitContext context, TypeSemantics semantics) + { + switch (semantics) + { + case TypeSemantics.GuidType: + writer.Write("g16"); + break; + case TypeSemantics.ObjectType: + writer.Write("cinterface(IInspectable)"); + break; + case TypeSemantics.Fundamental f: + writer.Write(GetFundamentalTypeGuidSignature(f.Type)); + break; + case TypeSemantics.Definition d: + WriteGuidSignatureForType(writer, context, d.Type); + break; + case TypeSemantics.Reference r: + { + // Resolve the reference to a TypeDefinition (cross-module struct field, etc.). + (string ns, string name) = r.Type.Names(); + TypeDefinition? resolved = null; + + if (context.Cache is not null) + { + resolved = r.Type.TryResolve(context.Cache.RuntimeContext) + ?? context.Cache.Find(ns, name); + } + + if (resolved is not null) + { + WriteGuidSignatureForType(writer, context, resolved); + } + } + break; + case TypeSemantics.GenericInstance gi: + writer.Write("pinterface({"); + IidExpressionGenerator.WriteGuid(writer, gi.GenericType, true); + writer.Write("};"); + for (int i = 0; i < gi.GenericArgs.Count; i++) + { + writer.WriteIf(i > 0, ";"); + + WriteGuidSignature(writer, context, gi.GenericArgs[i]); + } + writer.Write(")"); + break; + case TypeSemantics.GenericInstanceRef gir: + { + // Cross-module generic instance (e.g. Windows.Foundation.IReference + // appearing as a struct field). Resolve the generic type to a TypeDefinition + // so we can extract its [Guid]; recurse on each type argument. + (string ns, string name) = gir.GenericType.Names(); + TypeDefinition? resolved = null; + + if (context.Cache is not null) + { + resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) + ?? context.Cache.Find(ns, name); + } + + if (resolved is not null) + { + writer.Write("pinterface({"); + IidExpressionGenerator.WriteGuid(writer, resolved, true); + writer.Write("};"); + for (int i = 0; i < gir.GenericArgs.Count; i++) + { + writer.WriteIf(i > 0, ";"); + + WriteGuidSignature(writer, context, gir.GenericArgs[i]); + } + writer.Write(")"); + } + } + break; + } + } + + /// + /// Convenience overload of + /// that leases an from , + /// emits the GUID signature into it, and returns the resulting string. + /// + /// The active emit context. + /// The type semantics whose GUID signature is emitted. + /// The emitted GUID signature. + public static string WriteGuidSignature(ProjectionEmitContext context, TypeSemantics semantics) + { + using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); + IndentedTextWriter writer = writerOwner.Writer; + WriteGuidSignature(writer, context, semantics); + return writer.ToString(); + } + + /// + /// Writes the GUID signature fragment for , dispatched by category: + /// enums emit enum(name;underlying), structs emit struct(name;field-sigs), + /// delegates emit delegate({guid}), interfaces emit {guid}, and runtime classes + /// emit rc(name;default-interface-sig) (or fall back to {guid} when no default + /// interface is declared). + /// + /// The writer to emit to. + /// The active emit context. + /// The type to emit a signature for. + private static void WriteGuidSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + { + TypeCategory cat = TypeCategorization.GetCategory(type); + switch (cat) + { + case TypeCategory.Enum: + writer.Write("enum("); + TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); + TypedefNameWriter.WriteTypeParams(writer, type); + writer.Write(";"); + writer.Write(TypeCategorization.IsFlagsEnum(type) ? "u4" : "i4"); + writer.Write(")"); + break; + case TypeCategory.Struct: + writer.Write("struct("); + TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); + TypedefNameWriter.WriteTypeParams(writer, type); + writer.Write(";"); + bool first = true; + foreach (FieldDefinition field in type.Fields) + { + if (field.IsStatic) + { + continue; + } + + if (field.Signature is null) + { + continue; + } + + writer.WriteIf(!first, ";"); + + first = false; + WriteGuidSignature(writer, context, TypeSemanticsFactory.Get(field.Signature.FieldType)); + } + writer.Write(")"); + break; + case TypeCategory.Delegate: + writer.Write("delegate({"); + IidExpressionGenerator.WriteGuid(writer, type, true); + writer.Write("})"); + break; + case TypeCategory.Interface: + writer.Write("{"); + IidExpressionGenerator.WriteGuid(writer, type, true); + writer.Write("}"); + break; + case TypeCategory.Class: + ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); + + if (defaultIface is TypeDefinition di) + { + writer.Write("rc("); + TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); + TypedefNameWriter.WriteTypeParams(writer, type); + writer.Write(";"); + WriteGuidSignature(writer, context, new TypeSemantics.Definition(di)); + writer.Write(")"); + } + else + { + writer.Write("{"); + IidExpressionGenerator.WriteGuid(writer, type, true); + writer.Write("}"); + } + + break; + } + } +} From 08fd20992520e63b3da9716b75ce942f9bbe5be3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 13:30:14 -0700 Subject: [PATCH 103/171] Use GetSignature and avoid string allocation for IID Add SignatureGenerator.GetSignature to produce a GUID signature string via a pooled IndentedTextWriter, and make internal signature-writing APIs private/renamed (WriteSignature, WriteSignatureForType). Replace usages of the old public WriteGuidSignature helper. Update IidExpressionGenerator to call GetSignature and build the pinterface(...) input with a DefaultInterpolatedStringHandler to avoid allocating the full concatenated string; clear the handler after use. Also add System.Runtime.CompilerServices import for the interpolated handler. These changes reduce temporary allocations and encapsulate signature emission behind a single API. --- .../Helpers/IidExpressionGenerator.cs | 22 +++++-- .../Helpers/SignatureGenerator.cs | 59 +++++++++---------- 2 files changed, 46 insertions(+), 35 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 3634b3b40..907d38c2b 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Globalization; +using System.Runtime.CompilerServices; using System.Text.RegularExpressions; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; @@ -231,7 +232,7 @@ public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, Proje /// /// Writes a static IID property whose body is built from the parametric GUID signature - /// (computed via + /// (computed via /// for the type, then wrapped in the Windows.Foundation.IReference<T> /// pinterface to produce the IID_XReference hashed GUID). /// @@ -240,10 +241,21 @@ public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, Proje /// The type whose IReference<T> IID is emitted. public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string guidSig = SignatureGenerator.WriteGuidSignature(context, new TypeSemantics.Definition(type)); - string ireferenceGuidSig = "pinterface({61c17706-2d65-11e0-9ae8-d48564015472};" + guidSig + ")"; - Guid guidValue = GuidGenerator.Generate(ireferenceGuidSig); - byte[] bytes = guidValue.ToByteArray(); + string signature = SignatureGenerator.GetSignature(context, new TypeSemantics.Definition(type)); + Guid guid; + + // We can use an interpolated handler here to avoid allocating the 'string' for the full signature. + // The additional scope here is to ensure that the rest of the method never reuses this handler. + { + DefaultInterpolatedStringHandler handler = $$"""pinterface({61c17706-2d65-11e0-9ae8-d48564015472};{{signature}})"""; + + guid = GuidGenerator.Generate(handler.Text); + + // Don't forget to clear the handler after we used it, so its rented buffer can be returned + handler.Clear(); + } + + byte[] bytes = guid.ToByteArray(); writer.Write("public static ref readonly Guid "); WriteIidReferenceGuidPropertyName(writer, context, type); diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs index a793bafd6..8cdbf9dd8 100644 --- a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -24,6 +24,23 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; /// internal static class SignatureGenerator { + /// + /// Gets the signature for a given type. + /// + /// The active emit context. + /// The type semantics whose GUID signature is emitted. + /// The emitted GUID signature. + public static string GetSignature(ProjectionEmitContext context, TypeSemantics semantics) + { + using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); + + IndentedTextWriter writer = writerOwner.Writer; + + WriteSignature(writer, context, semantics); + + return writer.ToString(); + } + /// /// Returns the GUID-signature character code for a fundamental WinRT type (e.g. i4 /// for , string for ). @@ -32,7 +49,7 @@ internal static class SignatureGenerator /// The signature code. /// Thrown when /// is not a known fundamental type. - public static string GetFundamentalTypeGuidSignature(FundamentalType type) => type switch + private static string GetFundamentalTypeGuidSignature(FundamentalType type) => type switch { FundamentalType.Boolean => "b1", FundamentalType.Char => "c2", @@ -59,7 +76,7 @@ internal static class SignatureGenerator /// The writer to emit to. /// The active emit context (used for cross-module type resolution). /// The type semantics whose signature is emitted. - public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitContext context, TypeSemantics semantics) + private static void WriteSignature(IndentedTextWriter writer, ProjectionEmitContext context, TypeSemantics semantics) { switch (semantics) { @@ -73,23 +90,22 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC writer.Write(GetFundamentalTypeGuidSignature(f.Type)); break; case TypeSemantics.Definition d: - WriteGuidSignatureForType(writer, context, d.Type); + WriteSignatureForType(writer, context, d.Type); break; case TypeSemantics.Reference r: { - // Resolve the reference to a TypeDefinition (cross-module struct field, etc.). + // Resolve the reference to a 'TypeDefinition' (cross-module struct field, etc.). (string ns, string name) = r.Type.Names(); TypeDefinition? resolved = null; if (context.Cache is not null) { - resolved = r.Type.TryResolve(context.Cache.RuntimeContext) - ?? context.Cache.Find(ns, name); + resolved = r.Type.TryResolve(context.Cache.RuntimeContext) ?? context.Cache.Find(ns, name); } if (resolved is not null) { - WriteGuidSignatureForType(writer, context, resolved); + WriteSignatureForType(writer, context, resolved); } } break; @@ -101,7 +117,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC { writer.WriteIf(i > 0, ";"); - WriteGuidSignature(writer, context, gi.GenericArgs[i]); + WriteSignature(writer, context, gi.GenericArgs[i]); } writer.Write(")"); break; @@ -115,8 +131,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC if (context.Cache is not null) { - resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) - ?? context.Cache.Find(ns, name); + resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) ?? context.Cache.Find(ns, name); } if (resolved is not null) @@ -128,7 +143,7 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC { writer.WriteIf(i > 0, ";"); - WriteGuidSignature(writer, context, gir.GenericArgs[i]); + WriteSignature(writer, context, gir.GenericArgs[i]); } writer.Write(")"); } @@ -137,22 +152,6 @@ public static void WriteGuidSignature(IndentedTextWriter writer, ProjectionEmitC } } - /// - /// Convenience overload of - /// that leases an from , - /// emits the GUID signature into it, and returns the resulting string. - /// - /// The active emit context. - /// The type semantics whose GUID signature is emitted. - /// The emitted GUID signature. - public static string WriteGuidSignature(ProjectionEmitContext context, TypeSemantics semantics) - { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - WriteGuidSignature(writer, context, semantics); - return writer.ToString(); - } - /// /// Writes the GUID signature fragment for , dispatched by category: /// enums emit enum(name;underlying), structs emit struct(name;field-sigs), @@ -163,7 +162,7 @@ public static string WriteGuidSignature(ProjectionEmitContext context, TypeSeman /// The writer to emit to. /// The active emit context. /// The type to emit a signature for. - private static void WriteGuidSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) + private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { TypeCategory cat = TypeCategorization.GetCategory(type); switch (cat) @@ -197,7 +196,7 @@ private static void WriteGuidSignatureForType(IndentedTextWriter writer, Project writer.WriteIf(!first, ";"); first = false; - WriteGuidSignature(writer, context, TypeSemanticsFactory.Get(field.Signature.FieldType)); + WriteSignature(writer, context, TypeSemanticsFactory.Get(field.Signature.FieldType)); } writer.Write(")"); break; @@ -220,7 +219,7 @@ private static void WriteGuidSignatureForType(IndentedTextWriter writer, Project TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); TypedefNameWriter.WriteTypeParams(writer, type); writer.Write(";"); - WriteGuidSignature(writer, context, new TypeSemantics.Definition(di)); + WriteSignature(writer, context, new TypeSemantics.Definition(di)); writer.Write(")"); } else From 493de832a4a6996ad67e5bd57421ee91b8e601f7 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 13:58:20 -0700 Subject: [PATCH 104/171] Unify IID property emission via Guid + callbacks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit **`TypeDefinition.GetWindowsRuntimeGuid()` extension** (TypeDefinitionExtensions.cs): Reads the 11 positional fields of `[Windows.Foundation.Metadata.GuidAttribute]` and constructs a `System.Guid` directly via the `Guid(uint, ushort, ushort, byte, byte, byte, byte, byte, byte, byte, byte)` constructor. Uses `Convert.ToUInt32` / `Convert.ToUInt16` / `Convert.ToByte` for the boxed-element coercion (handles the `int`/`uint` / `short`/`ushort` / `sbyte`/`byte` element types that AsmResolver may return). Returns `Guid?` (`null` when the attribute is missing or malformed) so callers can `?? throw` with a meaningful exception. Replaces the removed `IidExpressionGenerator.GetGuidFields(TypeDefinition)` helper that returned a 4-element tuple plus local `ToUInt32`/`ToUInt16`/ `ToByte` switch helpers. **Three new callbacks** under `Factories/Callbacks/`: - `WriteGuidBytesCallback(Guid)`: writes 16 hex-formatted comma-separated bytes (e.g. `0xAA, 0xBB, ...`). - `WriteIidGuidPropertyNameCallback(context, type)`: emits `IID_X`. - `WriteIidReferenceGuidPropertyNameCallback(context, type)`: emits `IID_XReference`. Each follows the existing convention: factory method with the same name as the writer-method but no writer arg (overload returning the callback). **`IidExpressionGenerator` refactor:** - `WriteGuid` now has a primitive form taking a `Guid` (uses `stackalloc byte[16]` + `guid.TryWriteBytes` to extract fields allocation-free) and a convenience overload taking a `TypeDefinition` that forwards through `GetWindowsRuntimeGuid()`. - `WriteGuidBytes` is now primitive in `Guid` (no `TypeDefinition` overload needed — neither caller has that path); paired with a callback factory `WriteGuidBytes(Guid)` returning `WriteGuidBytesCallback`. - `WriteByte` takes `byte` directly (was `uint` with `& 0xFF` masks that are no longer needed now that the source is `Span`). - `WriteIidGuidPropertyName` / `WriteIidReferenceGuidPropertyName` each get a callback-factory overload alongside the writer overload. - `WriteIidGuidPropertyFromType` and `WriteIidGuidPropertyFromSignature` collapse from ~25-line broken-up emissions into single multiline interpolated string templates with the new callbacks as interpolation holes — the entire property body declaration is now visible at a glance. **External call-site migrations:** - `AbiTypeHelpers.WriteIidGuidReference`: 2 split-emission sites now use `WriteIidGuidPropertyNameCallback` in interpolated strings. - `ReferenceImplFactory.WriteReferenceImpl`: the `IID` get-only property emission collapses into a single multiline interpolated string using `WriteIidReferenceGuidPropertyNameCallback`. Validation: 763/763 byte-identical across pushnot/evwithui/windows scenarios; Writer + TestRunner build 0/0. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeDefinitionExtensions.cs | 46 ++++ .../Callbacks/WriteGuidBytesCallback.cs | 18 ++ .../WriteIidGuidPropertyNameCallback.cs | 21 ++ ...iteIidReferenceGuidPropertyNameCallback.cs | 21 ++ .../Factories/ReferenceImplFactory.cs | 20 +- .../Helpers/AbiTypeHelpers.cs | 8 +- .../Helpers/IidExpressionGenerator.cs | 198 ++++++++---------- 7 files changed, 210 insertions(+), 122 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidBytesCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidPropertyNameCallback.cs create mode 100644 src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceGuidPropertyNameCallback.cs diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 2ffc1d055..93683a05a 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -1,7 +1,9 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +using System; using System.Collections.Generic; +using System.Globalization; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; @@ -173,5 +175,49 @@ public bool HasNonObjectBaseType() CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute(VersionAttribute); return attr is not null && attr.TryGetFixedArgument(0, out int v) ? v : null; } + + /// + /// Tries to read the [Windows.Foundation.Metadata.GuidAttribute] on the type and reconstructs + /// it as a value. Returns if the attribute + /// is missing or its 11 positional fields (uint, ushort, ushort, then + /// 8 × byte) cannot be read. + /// + /// The parsed value, if successfully retrieved. + /// if the GUID was successfully retrieved; otherwise . + public bool TryGetWindowsRuntimeGuid(out Guid guid) + { + CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute("GuidAttribute"); + + if (attr is null || attr.Signature is null) + { + guid = default; + + return false; + } + + IList args = attr.Signature.FixedArguments; + + if (args.Count < 11) + { + guid = default; + + return false; + } + + guid = new Guid( + a: Convert.ToUInt32(args[0].Element, CultureInfo.InvariantCulture), + b: Convert.ToUInt16(args[1].Element, CultureInfo.InvariantCulture), + c: Convert.ToUInt16(args[2].Element, CultureInfo.InvariantCulture), + d: Convert.ToByte(args[3].Element, CultureInfo.InvariantCulture), + e: Convert.ToByte(args[4].Element, CultureInfo.InvariantCulture), + f: Convert.ToByte(args[5].Element, CultureInfo.InvariantCulture), + g: Convert.ToByte(args[6].Element, CultureInfo.InvariantCulture), + h: Convert.ToByte(args[7].Element, CultureInfo.InvariantCulture), + i: Convert.ToByte(args[8].Element, CultureInfo.InvariantCulture), + j: Convert.ToByte(args[9].Element, CultureInfo.InvariantCulture), + k: Convert.ToByte(args[10].Element, CultureInfo.InvariantCulture)); + + return true; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidBytesCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidBytesCallback.cs new file mode 100644 index 000000000..e2fe1d92e --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteGuidBytesCallback.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using System; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteGuidBytesCallback(Guid guid) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + IidExpressionGenerator.WriteGuidBytes(writer, guid); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidPropertyNameCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidPropertyNameCallback.cs new file mode 100644 index 000000000..cc740db78 --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidGuidPropertyNameCallback.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteIidGuidPropertyNameCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + IidExpressionGenerator.WriteIidGuidPropertyName(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceGuidPropertyNameCallback.cs b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceGuidPropertyNameCallback.cs new file mode 100644 index 000000000..5434c321c --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/Callbacks/WriteIidReferenceGuidPropertyNameCallback.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories.Callbacks; + +/// +internal readonly struct WriteIidReferenceGuidPropertyNameCallback( + ProjectionEmitContext context, + TypeDefinition type) : IIndentedTextWriterCallback +{ + /// + public void Write(IndentedTextWriter writer) + { + IidExpressionGenerator.WriteIidReferenceGuidPropertyName(writer, context, type); + } +} diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 7aa401081..7a7d5066d 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -144,19 +144,17 @@ public static int get_Value(void* thisPtr, void* result) } // IID property: 'public static ref readonly Guid IID' pointing at the reference type's IID. + WriteIidReferenceGuidPropertyNameCallback name = IidExpressionGenerator.WriteIidReferenceGuidPropertyName(context, type); + writer.WriteLine(); - writer.Write(isMultiline: true, """ - public static ref readonly Guid IID - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => ref global::ABI.InterfaceIIDs. - """); - IidExpressionGenerator.WriteIidReferenceGuidPropertyName(writer, context, type); - writer.WriteLine(isMultiline: true, """ - ; + writer.WriteLine(isMultiline: true, $$""" + public static ref readonly Guid IID + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => ref global::ABI.InterfaceIIDs.{{name}}; + } } - } - """); + """); writer.WriteLine(); } } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 7a8447946..ecd0f416e 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -173,8 +173,8 @@ public static void WriteIidGuidReference(IndentedTextWriter writer, ProjectionEm if (type.GenericParameters.Count != 0) { // Generic interface IID - call the unsafe accessor - IidExpressionGenerator.WriteIidGuidPropertyName(writer, context, type); - writer.Write("(null)"); + WriteIidGuidPropertyNameCallback iidName = IidExpressionGenerator.WriteIidGuidPropertyName(context, type); + writer.Write($"{iidName}(null)"); return; } @@ -186,8 +186,8 @@ public static void WriteIidGuidReference(IndentedTextWriter writer, ProjectionEm return; } - writer.Write("global::ABI.InterfaceIIDs."); - IidExpressionGenerator.WriteIidGuidPropertyName(writer, context, type); + WriteIidGuidPropertyNameCallback name = IidExpressionGenerator.WriteIidGuidPropertyName(context, type); + writer.Write($"global::ABI.InterfaceIIDs.{name}"); } /// diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 907d38c2b..2792027e6 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -2,14 +2,13 @@ // Licensed under the MIT License. using System; -using System.Collections.Generic; using System.Globalization; using System.Runtime.CompilerServices; using System.Text.RegularExpressions; using AsmResolver.DotNet; -using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Errors; using WindowsRuntime.ProjectionWriter.Factories; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Writers; @@ -31,7 +30,7 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; internal static partial class IidExpressionGenerator { [GeneratedRegex(@"[ :<>`,.]")] - private static partial Regex TypeNameEscapeRegex(); + private static partial Regex TypeNameEscapeRegex { get; } /// /// Escapes a type name into a C# identifier-safe form. @@ -39,7 +38,7 @@ internal static partial class IidExpressionGenerator public static string EscapeTypeNameForIdentifier(string typeName, bool stripGlobal = false, bool stripGlobalABI = false) { // Escape special chars first, then strip ONLY the prefix (not all occurrences). - string result = TypeNameEscapeRegex().Replace(typeName, "_"); + string result = TypeNameEscapeRegex.Replace(typeName, "_"); if (stripGlobalABI && typeName.StartsWith(GlobalAbiPrefix, StringComparison.Ordinal)) { @@ -54,81 +53,56 @@ public static string EscapeTypeNameForIdentifier(string typeName, bool stripGlob } /// - /// Reads the GUID values from the [GuidAttribute] of the type and returns them as a tuple. + /// Writes in canonical hyphenated string form + /// (e.g. 00000000-0000-0000-0000-000000000000). /// - public static (uint Data1, ushort Data2, ushort Data3, byte[] Data4)? GetGuidFields(TypeDefinition type) + /// The writer to emit to. + /// The GUID value. + /// When , hex digits are lower-case; otherwise upper-case. + private static void WriteGuid(IndentedTextWriter writer, Guid guid, bool lowerCase) { - CustomAttribute? attr = type.GetWindowsFoundationMetadataAttribute("GuidAttribute"); + Span bytes = stackalloc byte[16]; + _ = guid.TryWriteBytes(bytes); - if (attr is null || attr.Signature is null) - { - return null; - } + uint data1 = bytes[0] | ((uint)bytes[1] << 8) | ((uint)bytes[2] << 16) | ((uint)bytes[3] << 24); + ushort data2 = (ushort)(bytes[4] | (bytes[5] << 8)); + ushort data3 = (ushort)(bytes[6] | (bytes[7] << 8)); - IList args = attr.Signature.FixedArguments; + string fmt = lowerCase ? "x" : "X"; + // Format: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x + writer.Write($"{data1.ToString(fmt + "8", CultureInfo.InvariantCulture)}-{data2.ToString(fmt + "4", CultureInfo.InvariantCulture)}-{data3.ToString(fmt + "4", CultureInfo.InvariantCulture)}-"); - if (args.Count < 11) + for (int i = 8; i < 10; i++) { - return null; + writer.Write(bytes[i].ToString(fmt + "2", CultureInfo.InvariantCulture)); } - uint data1 = ToUInt32(args[0].Element); - ushort data2 = ToUInt16(args[1].Element); - ushort data3 = ToUInt16(args[2].Element); - byte[] data4 = new byte[8]; - for (int i = 0; i < 8; i++) - { - data4[i] = ToByte(args[3 + i].Element); - } - return (data1, data2, data3, data4); + writer.Write("-"); - static uint ToUInt32(object? v) => v switch + for (int i = 10; i < 16; i++) { - uint u => u, - int i => (uint)i, - _ => 0u - }; - static ushort ToUInt16(object? v) => v switch - { - ushort u => u, - short s => (ushort)s, - int i => (ushort)i, - _ => 0 - }; - static byte ToByte(object? v) => v switch - { - byte b => b, - sbyte sb => (byte)sb, - int i => (byte)i, - _ => 0 - }; + writer.Write(bytes[i].ToString(fmt + "2", CultureInfo.InvariantCulture)); + } } /// - /// Writes the GUID for in canonical hyphenated string form - /// (e.g. 00000000-0000-0000-0000-000000000000). + /// Writes the GUID for in canonical hyphenated string form. Reads + /// the [Guid] attribute on the type via + /// 's GetWindowsRuntimeGuid and forwards to + /// . /// /// The writer to emit to. /// The type whose [Guid] attribute is read. /// When , hex digits are lower-case; otherwise upper-case. + /// Thrown when the type has no [Guid] attribute. public static void WriteGuid(IndentedTextWriter writer, TypeDefinition type, bool lowerCase) { - (uint data1, ushort data2, ushort data3, byte[] data4) = GetGuidFields(type) ?? throw WellKnownProjectionWriterExceptions.MissingGuidAttribute($"{type.Namespace}.{type.Name}"); - string fmt = lowerCase ? "x" : "X"; - // Format: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x - writer.Write($"{data1.ToString(fmt + "8", CultureInfo.InvariantCulture)}-{data2.ToString(fmt + "4", CultureInfo.InvariantCulture)}-{data3.ToString(fmt + "4", CultureInfo.InvariantCulture)}-"); - - for (int i = 0; i < 2; i++) + if (!type.TryGetWindowsRuntimeGuid(out Guid guid)) { - writer.Write(data4[i].ToString(fmt + "2", CultureInfo.InvariantCulture)); + throw WellKnownProjectionWriterExceptions.MissingGuidAttribute($"{type.Namespace}.{type.Name}"); } - writer.Write("-"); - - for (int i = 2; i < 8; i++) - { - writer.Write(data4[i].ToString(fmt + "2", CultureInfo.InvariantCulture)); - } + WriteGuid(writer, guid, lowerCase); } /// @@ -141,88 +115,110 @@ public static string FormatGuid(TypeDefinition type, bool lowerCase) } /// - /// Writes the GUID bytes for as a hex byte list (e.g. + /// Writes the 16 bytes of as a hex byte list (e.g. /// 0x00, 0x00, ..., 0x00), formatted for embedding inside a C# collection /// expression that initializes a ReadOnlySpan<byte>. /// /// The writer to emit to. - /// The type whose [Guid] attribute is read. - public static void WriteGuidBytes(IndentedTextWriter writer, TypeDefinition type) + /// The GUID whose bytes are emitted. + public static void WriteGuidBytes(IndentedTextWriter writer, Guid guid) { - (uint data1, ushort data2, ushort data3, byte[] data4) = GetGuidFields(type) ?? throw WellKnownProjectionWriterExceptions.MissingGuidAttribute($"{type.Namespace}.{type.Name}"); - WriteByte(writer, (data1 >> 0) & 0xFF, true); - WriteByte(writer, (data1 >> 8) & 0xFF, false); - WriteByte(writer, (data1 >> 16) & 0xFF, false); - WriteByte(writer, (data1 >> 24) & 0xFF, false); - WriteByte(writer, (uint)((data2 >> 0) & 0xFF), false); - WriteByte(writer, (uint)((data2 >> 8) & 0xFF), false); - WriteByte(writer, (uint)((data3 >> 0) & 0xFF), false); - WriteByte(writer, (uint)((data3 >> 8) & 0xFF), false); - - for (int i = 0; i < 8; i++) + Span bytes = stackalloc byte[16]; + _ = guid.TryWriteBytes(bytes); + + for (int i = 0; i < 16; i++) { - WriteByte(writer, data4[i], false); + WriteByte(writer, bytes[i], first: i == 0); } } + /// + /// A callback that writes the bytes when invoked. + public static WriteGuidBytesCallback WriteGuidBytes(Guid guid) + { + return new(guid); + } + /// /// Writes a single byte as 0xXX (or , 0xXX when not the first byte in a list). /// /// The writer to emit to. - /// The byte value (only the low 8 bits are used). + /// The byte value. /// When , omits the leading ", " separator. - private static void WriteByte(IndentedTextWriter writer, uint b, bool first) + private static void WriteByte(IndentedTextWriter writer, byte b, bool first) { writer.WriteIf(!first, ", "); - writer.Write($"0x{(b & 0xFF).ToString("X", CultureInfo.InvariantCulture)}"); + writer.Write($"0x{b.ToString("X", CultureInfo.InvariantCulture)}"); } /// /// Writes the property name IID_X for the IID property of . /// + /// The writer to emit to. + /// The active emit context. + /// The type whose IID property name is emitted. public static void WriteIidGuidPropertyName(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string name = EscapeTypeNameForIdentifier(TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true).Format(), true, true); writer.Write($"IID_{name}"); } + /// + /// A callback that writes the property name when invoked. + public static WriteIidGuidPropertyNameCallback WriteIidGuidPropertyName(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + /// - /// Writes the property name IID_XReference for the reference IID property. + /// Writes the property name IID_XReference for the IReference<T> IID + /// property of . /// + /// The writer to emit to. + /// The active emit context. + /// The type whose reference IID property name is emitted. public static void WriteIidReferenceGuidPropertyName(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string name = EscapeTypeNameForIdentifier(TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.ABI, true).Format(), true, true); writer.Write($"IID_{name}Reference"); } + /// + /// A callback that writes the property name when invoked. + public static WriteIidReferenceGuidPropertyNameCallback WriteIidReferenceGuidPropertyName(ProjectionEmitContext context, TypeDefinition type) + { + return new(context, type); + } + /// /// Writes a static IID property whose body is built from the [Guid] attribute bytes /// of . The property is named IID_X (see - /// ) and returns a ref readonly Guid backed by - /// a stack-allocated ReadOnlySpan<byte>. + /// ) and returns + /// a ref readonly Guid backed by a stack-allocated ReadOnlySpan<byte>. /// /// The writer to emit to. /// The active emit context. /// The type whose [Guid] attribute is read. + /// Thrown when the type has no [Guid] attribute. public static void WriteIidGuidPropertyFromType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - writer.Write("public static ref readonly Guid "); - WriteIidGuidPropertyName(writer, context, type); - writer.WriteLine(); - writer.Write(isMultiline: true, """ + if (!type.TryGetWindowsRuntimeGuid(out Guid guid)) + { + throw WellKnownProjectionWriterExceptions.MissingGuidAttribute($"{type.Namespace}.{type.Name}"); + } + + WriteIidGuidPropertyNameCallback name = WriteIidGuidPropertyName(context, type); + WriteGuidBytesCallback bytes = WriteGuidBytes(guid); + + writer.WriteLine(isMultiline: true, $$""" + public static ref readonly Guid {{name}} { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = - [ - - """); - WriteGuidBytes(writer, type); - writer.WriteLine(); - writer.WriteLine(isMultiline: true, """ - ]; + ReadOnlySpan data = [{{bytes}}]; + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); } } @@ -255,29 +251,17 @@ public static void WriteIidGuidPropertyFromSignature(IndentedTextWriter writer, handler.Clear(); } - byte[] bytes = guid.ToByteArray(); + WriteIidReferenceGuidPropertyNameCallback name = WriteIidReferenceGuidPropertyName(context, type); + WriteGuidBytesCallback bytes = WriteGuidBytes(guid); - writer.Write("public static ref readonly Guid "); - WriteIidReferenceGuidPropertyName(writer, context, type); - writer.WriteLine(); - writer.Write(isMultiline: true, """ + writer.WriteLine(isMultiline: true, $$""" + public static ref readonly Guid {{name}} { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { - ReadOnlySpan data = - [ - - """); - for (int i = 0; i < 16; i++) - { - writer.WriteIf(i > 0, ", "); + ReadOnlySpan data = [{{bytes}}]; - writer.Write($"0x{bytes[i].ToString("X", CultureInfo.InvariantCulture)}"); - } - writer.WriteLine(); - writer.WriteLine(isMultiline: true, """ - ]; return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); } } From a13fc380142821d2a513e429effe4e61860cebd6 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 13:59:04 -0700 Subject: [PATCH 105/171] Inline TypeMappings static initialization Replace the Build() factory with an explicit static initializer for TypeMappings. The change inlines the previously assembled dictionary (and removed the Add helper and Build method), creating nested dictionaries and freezing them via ToFrozenDictionary for namespaces like Microsoft.UI.Xaml, Windows.Foundation, Windows.UI.Xaml, and others. Preserves the same mapped type entries while simplifying initialization code. --- .../Helpers/MappedTypes.cs | 459 +++++++++--------- 1 file changed, 231 insertions(+), 228 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs b/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs index 96f1b9e84..8e928c65a 100644 --- a/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs @@ -31,7 +31,237 @@ internal readonly record struct MappedType( /// internal static class MappedTypes { - private static readonly FrozenDictionary> TypeMappings = Build(); + /// + /// The mapping of all custom-mapped types. + /// + private static readonly FrozenDictionary> TypeMappings = new Dictionary> + { + ["Microsoft.UI.Xaml"] = new Dictionary + { + ["CornerRadius"] = new("CornerRadius", "Microsoft.UI.Xaml", "CornerRadius", false, false, true), + ["CornerRadiusHelper"] = new("CornerRadiusHelper", "", ""), + ["Duration"] = new("Duration", "Microsoft.UI.Xaml", "Duration", false, false, true), + ["DurationHelper"] = new("DurationHelper", "", ""), + ["GridLength"] = new("GridLength", "Microsoft.UI.Xaml", "GridLength", false, false, true), + ["GridLengthHelper"] = new("GridLengthHelper", "", ""), + ["ICornerRadiusHelper"] = new("ICornerRadiusHelper", "", ""), + ["ICornerRadiusHelperStatics"] = new("ICornerRadiusHelperStatics", "", ""), + ["IDurationHelper"] = new("IDurationHelper", "", ""), + ["IDurationHelperStatics"] = new("IDurationHelperStatics", "", ""), + ["IGridLengthHelper"] = new("IGridLengthHelper", "", ""), + ["IGridLengthHelperStatics"] = new("IGridLengthHelperStatics", "", ""), + ["IThicknessHelper"] = new("IThicknessHelper", "", ""), + ["IThicknessHelperStatics"] = new("IThicknessHelperStatics", "", ""), + ["IXamlServiceProvider"] = new("IXamlServiceProvider", "System", "IServiceProvider"), + ["ThicknessHelper"] = new("ThicknessHelper", "", ""), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Controls.Primitives"] = new Dictionary + { + ["GeneratorPositionHelper"] = new("GeneratorPositionHelper", "", ""), + ["IGeneratorPositionHelper"] = new("IGeneratorPositionHelper", "", ""), + ["IGeneratorPositionHelperStatics"] = new("IGeneratorPositionHelperStatics", "", ""), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Data"] = new Dictionary + { + ["DataErrorsChangedEventArgs"] = new("DataErrorsChangedEventArgs", "System.ComponentModel", "DataErrorsChangedEventArgs"), + ["INotifyDataErrorInfo"] = new("INotifyDataErrorInfo", "System.ComponentModel", "INotifyDataErrorInfo", true, true), + ["INotifyPropertyChanged"] = new("INotifyPropertyChanged", "System.ComponentModel", "INotifyPropertyChanged"), + ["PropertyChangedEventArgs"] = new("PropertyChangedEventArgs", "System.ComponentModel", "PropertyChangedEventArgs"), + ["PropertyChangedEventHandler"] = new("PropertyChangedEventHandler", "System.ComponentModel", "PropertyChangedEventHandler"), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Input"] = new Dictionary + { + ["ICommand"] = new("ICommand", "System.Windows.Input", "ICommand", true), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Interop"] = new Dictionary + { + ["IBindableIterable"] = new("IBindableIterable", "System.Collections", "IEnumerable", true, true), + ["IBindableIterator"] = new("IBindableIterator", "System.Collections", "IEnumerator", true, true), + ["IBindableVector"] = new("IBindableVector", "System.Collections", "IList", true, true), + ["INotifyCollectionChanged"] = new("INotifyCollectionChanged", "System.Collections.Specialized", "INotifyCollectionChanged", true), + ["NotifyCollectionChangedAction"] = new("NotifyCollectionChangedAction", "System.Collections.Specialized", "NotifyCollectionChangedAction"), + ["NotifyCollectionChangedEventArgs"] = new("NotifyCollectionChangedEventArgs", "System.Collections.Specialized", "NotifyCollectionChangedEventArgs", true), + ["NotifyCollectionChangedEventHandler"] = new("NotifyCollectionChangedEventHandler", "System.Collections.Specialized", "NotifyCollectionChangedEventHandler", true), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Media"] = new Dictionary + { + ["IMatrixHelper"] = new("IMatrixHelper", "", ""), + ["IMatrixHelperStatics"] = new("IMatrixHelperStatics", "", ""), + ["MatrixHelper"] = new("MatrixHelper", "", ""), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Media.Animation"] = new Dictionary + { + ["IKeyTimeHelper"] = new("IKeyTimeHelper", "", ""), + ["IKeyTimeHelperStatics"] = new("IKeyTimeHelperStatics", "", ""), + ["IRepeatBehaviorHelper"] = new("IRepeatBehaviorHelper", "", ""), + ["IRepeatBehaviorHelperStatics"] = new("IRepeatBehaviorHelperStatics", "", ""), + ["KeyTime"] = new("KeyTime", "Microsoft.UI.Xaml.Media.Animation", "KeyTime", false, false, true), + ["KeyTimeHelper"] = new("KeyTimeHelper", "", ""), + ["RepeatBehavior"] = new("RepeatBehavior", "Microsoft.UI.Xaml.Media.Animation", "RepeatBehavior", false, false, true), + ["RepeatBehaviorHelper"] = new("RepeatBehaviorHelper", "", ""), + }.ToFrozenDictionary(), + ["Microsoft.UI.Xaml.Media.Media3D"] = new Dictionary + { + ["IMatrix3DHelper"] = new("IMatrix3DHelper", "", ""), + ["IMatrix3DHelperStatics"] = new("IMatrix3DHelperStatics", "", ""), + ["Matrix3D"] = new("Matrix3D", "Microsoft.UI.Xaml.Media.Media3D", "Matrix3D", false, false, true), + ["Matrix3DHelper"] = new("Matrix3DHelper", "", ""), + }.ToFrozenDictionary(), + [WindowsFoundation] = new Dictionary + { + ["AsyncActionCompletedHandler"] = new("AsyncActionCompletedHandler", WindowsFoundation, "AsyncActionCompletedHandler"), + ["AsyncActionProgressHandler`1"] = new("AsyncActionProgressHandler`1", WindowsFoundation, "AsyncActionProgressHandler`1"), + ["AsyncActionWithProgressCompletedHandler`1"] = new("AsyncActionWithProgressCompletedHandler`1", WindowsFoundation, "AsyncActionWithProgressCompletedHandler`1"), + ["AsyncOperationCompletedHandler`1"] = new("AsyncOperationCompletedHandler`1", WindowsFoundation, "AsyncOperationCompletedHandler`1"), + ["AsyncOperationProgressHandler`2"] = new("AsyncOperationProgressHandler`2", WindowsFoundation, "AsyncOperationProgressHandler`2"), + ["AsyncOperationWithProgressCompletedHandler`2"] = new("AsyncOperationWithProgressCompletedHandler`2", WindowsFoundation, "AsyncOperationWithProgressCompletedHandler`2"), + ["AsyncStatus"] = new("AsyncStatus", WindowsFoundation, "AsyncStatus"), + ["DateTime"] = new("DateTime", "System", "DateTimeOffset", true), + ["EventHandler`1"] = new("EventHandler`1", "System", "EventHandler`1", false), + ["EventRegistrationToken"] = new("EventRegistrationToken", "WindowsRuntime.InteropServices", "EventRegistrationToken", false), + ["FoundationContract"] = new("FoundationContract", WindowsFoundation, "FoundationContract"), + [HResult] = new(HResult, "System", "Exception", true), + ["IAsyncAction"] = new("IAsyncAction", WindowsFoundation, "IAsyncAction"), + ["IAsyncActionWithProgress`1"] = new("IAsyncActionWithProgress`1", WindowsFoundation, "IAsyncActionWithProgress`1"), + ["IAsyncInfo"] = new("IAsyncInfo", WindowsFoundation, "IAsyncInfo"), + ["IAsyncOperationWithProgress`2"] = new("IAsyncOperationWithProgress`2", WindowsFoundation, "IAsyncOperationWithProgress`2"), + ["IAsyncOperation`1"] = new("IAsyncOperation`1", WindowsFoundation, "IAsyncOperation`1"), + ["IClosable"] = new("IClosable", "System", "IDisposable", true, true), + ["IMemoryBufferReference"] = new("IMemoryBufferReference", WindowsFoundation, "IMemoryBufferReference"), + ["IPropertyValue"] = new("IPropertyValue", WindowsFoundation, "IPropertyValue", true), + ["IReferenceArray`1"] = new("IReferenceArray`1", WindowsFoundation, "IReferenceArray", true), + [IReferenceGeneric] = new(IReferenceGeneric, "System", NullableGeneric, true), + ["IStringable"] = new("IStringable", WindowsFoundation, "IStringable"), + ["Point"] = new("Point", WindowsFoundation, "Point"), + ["PropertyType"] = new("PropertyType", WindowsFoundation, "PropertyType"), + ["Rect"] = new("Rect", WindowsFoundation, "Rect"), + ["Size"] = new("Size", WindowsFoundation, "Size"), + ["TimeSpan"] = new("TimeSpan", "System", "TimeSpan", true), + ["TypedEventHandler`2"] = new("TypedEventHandler`2", "System", "EventHandler`2", false), + ["UniversalApiContract"] = new("UniversalApiContract", WindowsFoundation, "UniversalApiContract"), + ["Uri"] = new("Uri", "System", "Uri", true), + }.ToFrozenDictionary(), + [WindowsFoundationCollections] = new Dictionary + { + ["CollectionChange"] = new("CollectionChange", WindowsFoundationCollections, "CollectionChange"), + ["IIterable`1"] = new("IIterable`1", "System.Collections.Generic", "IEnumerable`1", true, true), + ["IIterator`1"] = new("IIterator`1", "System.Collections.Generic", "IEnumerator`1", true, true), + ["IKeyValuePair`2"] = new("IKeyValuePair`2", "System.Collections.Generic", "KeyValuePair`2", true), + ["IMapChangedEventArgs`1"] = new("IMapChangedEventArgs`1", WindowsFoundationCollections, "IMapChangedEventArgs`1"), + ["IMapView`2"] = new("IMapView`2", "System.Collections.Generic", "IReadOnlyDictionary`2", true, true), + ["IMap`2"] = new("IMap`2", "System.Collections.Generic", "IDictionary`2", true, true), + ["IObservableMap`2"] = new("IObservableMap`2", WindowsFoundationCollections, "IObservableMap`2"), + ["IObservableVector`1"] = new("IObservableVector`1", WindowsFoundationCollections, "IObservableVector`1"), + ["IVectorChangedEventArgs"] = new("IVectorChangedEventArgs", WindowsFoundationCollections, "IVectorChangedEventArgs"), + ["IVectorView`1"] = new("IVectorView`1", "System.Collections.Generic", "IReadOnlyList`1", true, true), + ["IVector`1"] = new("IVector`1", "System.Collections.Generic", "IList`1", true, true), + ["MapChangedEventHandler`2"] = new("MapChangedEventHandler`2", WindowsFoundationCollections, "MapChangedEventHandler`2"), + ["VectorChangedEventHandler`1"] = new("VectorChangedEventHandler`1", WindowsFoundationCollections, "VectorChangedEventHandler`1"), + }.ToFrozenDictionary(), + [WindowsFoundationMetadata] = new Dictionary + { + ["ApiContractAttribute"] = new("ApiContractAttribute", WindowsFoundationMetadata, "ApiContractAttribute"), + ["AttributeTargets"] = new("AttributeTargets", "System", "AttributeTargets"), + ["AttributeUsageAttribute"] = new("AttributeUsageAttribute", "System", "AttributeUsageAttribute"), + [ContractVersionAttribute] = new(ContractVersionAttribute, WindowsFoundationMetadata, ContractVersionAttribute), + }.ToFrozenDictionary(), + ["Windows.Foundation.Numerics"] = new Dictionary + { + ["Matrix3x2"] = new("Matrix3x2", "System.Numerics", "Matrix3x2"), + ["Matrix4x4"] = new("Matrix4x4", "System.Numerics", "Matrix4x4"), + ["Plane"] = new("Plane", "System.Numerics", "Plane"), + ["Quaternion"] = new("Quaternion", "System.Numerics", "Quaternion"), + ["Vector2"] = new("Vector2", "System.Numerics", "Vector2"), + ["Vector3"] = new("Vector3", "System.Numerics", "Vector3"), + ["Vector4"] = new("Vector4", "System.Numerics", "Vector4"), + }.ToFrozenDictionary(), + ["Windows.Storage.Streams"] = new Dictionary + { + ["IBuffer"] = new("IBuffer", "Windows.Storage.Streams", "IBuffer"), + ["IInputStream"] = new("IInputStream", "Windows.Storage.Streams", "IInputStream"), + ["IOutputStream"] = new("IOutputStream", "Windows.Storage.Streams", "IOutputStream"), + ["IRandomAccessStream"] = new("IRandomAccessStream", "Windows.Storage.Streams", "IRandomAccessStream"), + ["InputStreamOptions"] = new("InputStreamOptions", "Windows.Storage.Streams", "InputStreamOptions"), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml"] = new Dictionary + { + ["CornerRadius"] = new("CornerRadius", "Windows.UI.Xaml", "CornerRadius", false, false, true), + ["CornerRadiusHelper"] = new("CornerRadiusHelper", "", ""), + ["Duration"] = new("Duration", "Windows.UI.Xaml", "Duration", false, false, true), + ["DurationHelper"] = new("DurationHelper", "", ""), + ["GridLength"] = new("GridLength", "Windows.UI.Xaml", "GridLength", false, false, true), + ["GridLengthHelper"] = new("GridLengthHelper", "", ""), + ["ICornerRadiusHelper"] = new("ICornerRadiusHelper", "", ""), + ["ICornerRadiusHelperStatics"] = new("ICornerRadiusHelperStatics", "", ""), + ["IDurationHelper"] = new("IDurationHelper", "", ""), + ["IDurationHelperStatics"] = new("IDurationHelperStatics", "", ""), + ["IGridLengthHelper"] = new("IGridLengthHelper", "", ""), + ["IGridLengthHelperStatics"] = new("IGridLengthHelperStatics", "", ""), + ["IThicknessHelper"] = new("IThicknessHelper", "", ""), + ["IThicknessHelperStatics"] = new("IThicknessHelperStatics", "", ""), + ["IXamlServiceProvider"] = new("IXamlServiceProvider", "System", "IServiceProvider"), + ["ThicknessHelper"] = new("ThicknessHelper", "", ""), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml.Controls.Primitives"] = new Dictionary + { + ["GeneratorPositionHelper"] = new("GeneratorPositionHelper", "", ""), + ["IGeneratorPositionHelper"] = new("IGeneratorPositionHelper", "", ""), + ["IGeneratorPositionHelperStatics"] = new("IGeneratorPositionHelperStatics", "", ""), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml.Data"] = new Dictionary + { + ["DataErrorsChangedEventArgs"] = new("DataErrorsChangedEventArgs", "System.ComponentModel", "DataErrorsChangedEventArgs"), + ["INotifyDataErrorInfo"] = new("INotifyDataErrorInfo", "System.ComponentModel", "INotifyDataErrorInfo", true, true), + ["INotifyPropertyChanged"] = new("INotifyPropertyChanged", "System.ComponentModel", "INotifyPropertyChanged"), + ["PropertyChangedEventArgs"] = new("PropertyChangedEventArgs", "System.ComponentModel", "PropertyChangedEventArgs"), + ["PropertyChangedEventHandler"] = new("PropertyChangedEventHandler", "System.ComponentModel", "PropertyChangedEventHandler"), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml.Input"] = new Dictionary + { + ["ICommand"] = new("ICommand", "System.Windows.Input", "ICommand", true), + }.ToFrozenDictionary(), + [WindowsUIXamlInterop] = new Dictionary + { + ["IBindableIterable"] = new("IBindableIterable", "System.Collections", "IEnumerable", true, true), + ["IBindableIterator"] = new("IBindableIterator", "System.Collections", "IEnumerator", true, true), + ["IBindableVector"] = new("IBindableVector", "System.Collections", "IList", true, true), + ["INotifyCollectionChanged"] = new("INotifyCollectionChanged", "System.Collections.Specialized", "INotifyCollectionChanged", true), + ["NotifyCollectionChangedAction"] = new("NotifyCollectionChangedAction", "System.Collections.Specialized", "NotifyCollectionChangedAction"), + ["NotifyCollectionChangedEventArgs"] = new("NotifyCollectionChangedEventArgs", "System.Collections.Specialized", "NotifyCollectionChangedEventArgs", true), + ["NotifyCollectionChangedEventHandler"] = new("NotifyCollectionChangedEventHandler", "System.Collections.Specialized", "NotifyCollectionChangedEventHandler", true), + ["TypeKind"] = new("TypeKind", WindowsUIXamlInterop, "TypeKind", true), + [TypeName] = new(TypeName, "System", "Type", true), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml.Media"] = new Dictionary + { + ["IMatrixHelper"] = new("IMatrixHelper", "", ""), + ["IMatrixHelperStatics"] = new("IMatrixHelperStatics", "", ""), + ["MatrixHelper"] = new("MatrixHelper", "", ""), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml.Media.Animation"] = new Dictionary + { + ["IKeyTimeHelper"] = new("IKeyTimeHelper", "", ""), + ["IKeyTimeHelperStatics"] = new("IKeyTimeHelperStatics", "", ""), + ["IRepeatBehaviorHelper"] = new("IRepeatBehaviorHelper", "", ""), + ["IRepeatBehaviorHelperStatics"] = new("IRepeatBehaviorHelperStatics", "", ""), + ["KeyTime"] = new("KeyTime", "Windows.UI.Xaml.Media.Animation", "KeyTime", false, false, true), + ["KeyTimeHelper"] = new("KeyTimeHelper", "", ""), + ["RepeatBehavior"] = new("RepeatBehavior", "Windows.UI.Xaml.Media.Animation", "RepeatBehavior", false, false, true), + ["RepeatBehaviorHelper"] = new("RepeatBehaviorHelper", "", ""), + }.ToFrozenDictionary(), + ["Windows.UI.Xaml.Media.Media3D"] = new Dictionary + { + ["IMatrix3DHelper"] = new("IMatrix3DHelper", "", ""), + ["IMatrix3DHelperStatics"] = new("IMatrix3DHelperStatics", "", ""), + ["Matrix3D"] = new("Matrix3D", "Windows.UI.Xaml.Media.Media3D", "Matrix3D", false, false, true), + ["Matrix3DHelper"] = new("Matrix3DHelper", "", ""), + }.ToFrozenDictionary(), + [WindowsRuntimeInternal] = new Dictionary + { + ["HWND"] = new("HWND", "System", "IntPtr"), + ["ProjectionInternalAttribute"] = new("ProjectionInternalAttribute", "", ""), + }.ToFrozenDictionary(), + }.ToFrozenDictionary(); /// /// Returns the entry for the type identified by @@ -88,231 +318,4 @@ public static bool ApplyMapping(ref string typeNamespace, ref string typeName) return false; } - - private static FrozenDictionary> Build() - { - Dictionary> result = []; - - // helper to add a type entry - void Add(string ns, MappedType mt) - { - if (!result.TryGetValue(ns, out Dictionary? bag)) - { - bag = []; - result[ns] = bag; - } - - bag[mt.AbiName] = mt; - } - - // Microsoft.UI.Xaml - Add("Microsoft.UI.Xaml", new("CornerRadius", "Microsoft.UI.Xaml", "CornerRadius", false, false, true)); - Add("Microsoft.UI.Xaml", new("CornerRadiusHelper", "", "")); - Add("Microsoft.UI.Xaml", new("Duration", "Microsoft.UI.Xaml", "Duration", false, false, true)); - Add("Microsoft.UI.Xaml", new("DurationHelper", "", "")); - Add("Microsoft.UI.Xaml", new("GridLength", "Microsoft.UI.Xaml", "GridLength", false, false, true)); - Add("Microsoft.UI.Xaml", new("GridLengthHelper", "", "")); - Add("Microsoft.UI.Xaml", new("ICornerRadiusHelper", "", "")); - Add("Microsoft.UI.Xaml", new("ICornerRadiusHelperStatics", "", "")); - Add("Microsoft.UI.Xaml", new("IDurationHelper", "", "")); - Add("Microsoft.UI.Xaml", new("IDurationHelperStatics", "", "")); - Add("Microsoft.UI.Xaml", new("IGridLengthHelper", "", "")); - Add("Microsoft.UI.Xaml", new("IGridLengthHelperStatics", "", "")); - Add("Microsoft.UI.Xaml", new("IThicknessHelper", "", "")); - Add("Microsoft.UI.Xaml", new("IThicknessHelperStatics", "", "")); - Add("Microsoft.UI.Xaml", new("IXamlServiceProvider", "System", "IServiceProvider")); - Add("Microsoft.UI.Xaml", new("ThicknessHelper", "", "")); - - // Microsoft.UI.Xaml.Controls.Primitives - Add("Microsoft.UI.Xaml.Controls.Primitives", new("GeneratorPositionHelper", "", "")); - Add("Microsoft.UI.Xaml.Controls.Primitives", new("IGeneratorPositionHelper", "", "")); - Add("Microsoft.UI.Xaml.Controls.Primitives", new("IGeneratorPositionHelperStatics", "", "")); - - // Microsoft.UI.Xaml.Data - Add("Microsoft.UI.Xaml.Data", new("DataErrorsChangedEventArgs", "System.ComponentModel", "DataErrorsChangedEventArgs")); - Add("Microsoft.UI.Xaml.Data", new("INotifyDataErrorInfo", "System.ComponentModel", "INotifyDataErrorInfo", true, true)); - Add("Microsoft.UI.Xaml.Data", new("INotifyPropertyChanged", "System.ComponentModel", "INotifyPropertyChanged")); - Add("Microsoft.UI.Xaml.Data", new("PropertyChangedEventArgs", "System.ComponentModel", "PropertyChangedEventArgs")); - Add("Microsoft.UI.Xaml.Data", new("PropertyChangedEventHandler", "System.ComponentModel", "PropertyChangedEventHandler")); - - // Microsoft.UI.Xaml.Input - Add("Microsoft.UI.Xaml.Input", new("ICommand", "System.Windows.Input", "ICommand", true)); - - // Microsoft.UI.Xaml.Interop - Add("Microsoft.UI.Xaml.Interop", new("IBindableIterable", "System.Collections", "IEnumerable", true, true)); - Add("Microsoft.UI.Xaml.Interop", new("IBindableIterator", "System.Collections", "IEnumerator", true, true)); - Add("Microsoft.UI.Xaml.Interop", new("IBindableVector", "System.Collections", "IList", true, true)); - Add("Microsoft.UI.Xaml.Interop", new("INotifyCollectionChanged", "System.Collections.Specialized", "INotifyCollectionChanged", true)); - Add("Microsoft.UI.Xaml.Interop", new("NotifyCollectionChangedAction", "System.Collections.Specialized", "NotifyCollectionChangedAction")); - Add("Microsoft.UI.Xaml.Interop", new("NotifyCollectionChangedEventArgs", "System.Collections.Specialized", "NotifyCollectionChangedEventArgs", true)); - Add("Microsoft.UI.Xaml.Interop", new("NotifyCollectionChangedEventHandler", "System.Collections.Specialized", "NotifyCollectionChangedEventHandler", true)); - - // Microsoft.UI.Xaml.Media - Add("Microsoft.UI.Xaml.Media", new("IMatrixHelper", "", "")); - Add("Microsoft.UI.Xaml.Media", new("IMatrixHelperStatics", "", "")); - Add("Microsoft.UI.Xaml.Media", new("MatrixHelper", "", "")); - - // Microsoft.UI.Xaml.Media.Animation - Add("Microsoft.UI.Xaml.Media.Animation", new("IKeyTimeHelper", "", "")); - Add("Microsoft.UI.Xaml.Media.Animation", new("IKeyTimeHelperStatics", "", "")); - Add("Microsoft.UI.Xaml.Media.Animation", new("IRepeatBehaviorHelper", "", "")); - Add("Microsoft.UI.Xaml.Media.Animation", new("IRepeatBehaviorHelperStatics", "", "")); - Add("Microsoft.UI.Xaml.Media.Animation", new("KeyTime", "Microsoft.UI.Xaml.Media.Animation", "KeyTime", false, false, true)); - Add("Microsoft.UI.Xaml.Media.Animation", new("KeyTimeHelper", "", "")); - Add("Microsoft.UI.Xaml.Media.Animation", new("RepeatBehavior", "Microsoft.UI.Xaml.Media.Animation", "RepeatBehavior", false, false, true)); - Add("Microsoft.UI.Xaml.Media.Animation", new("RepeatBehaviorHelper", "", "")); - - // Microsoft.UI.Xaml.Media.Media3D - Add("Microsoft.UI.Xaml.Media.Media3D", new("IMatrix3DHelper", "", "")); - Add("Microsoft.UI.Xaml.Media.Media3D", new("IMatrix3DHelperStatics", "", "")); - Add("Microsoft.UI.Xaml.Media.Media3D", new("Matrix3D", "Microsoft.UI.Xaml.Media.Media3D", "Matrix3D", false, false, true)); - Add("Microsoft.UI.Xaml.Media.Media3D", new("Matrix3DHelper", "", "")); - - // Windows.Foundation - Add(WindowsFoundation, new("AsyncActionCompletedHandler", WindowsFoundation, "AsyncActionCompletedHandler")); - Add(WindowsFoundation, new("AsyncActionProgressHandler`1", WindowsFoundation, "AsyncActionProgressHandler`1")); - Add(WindowsFoundation, new("AsyncActionWithProgressCompletedHandler`1", WindowsFoundation, "AsyncActionWithProgressCompletedHandler`1")); - Add(WindowsFoundation, new("AsyncOperationCompletedHandler`1", WindowsFoundation, "AsyncOperationCompletedHandler`1")); - Add(WindowsFoundation, new("AsyncOperationProgressHandler`2", WindowsFoundation, "AsyncOperationProgressHandler`2")); - Add(WindowsFoundation, new("AsyncOperationWithProgressCompletedHandler`2", WindowsFoundation, "AsyncOperationWithProgressCompletedHandler`2")); - Add(WindowsFoundation, new("AsyncStatus", WindowsFoundation, "AsyncStatus")); - Add(WindowsFoundation, new("DateTime", "System", "DateTimeOffset", true)); - Add(WindowsFoundation, new("EventHandler`1", "System", "EventHandler`1", false)); - Add(WindowsFoundation, new("EventRegistrationToken", "WindowsRuntime.InteropServices", "EventRegistrationToken", false)); - Add(WindowsFoundation, new("FoundationContract", WindowsFoundation, "FoundationContract")); - Add(WindowsFoundation, new(HResult, "System", "Exception", true)); - Add(WindowsFoundation, new("IAsyncAction", WindowsFoundation, "IAsyncAction")); - Add(WindowsFoundation, new("IAsyncActionWithProgress`1", WindowsFoundation, "IAsyncActionWithProgress`1")); - Add(WindowsFoundation, new("IAsyncInfo", WindowsFoundation, "IAsyncInfo")); - Add(WindowsFoundation, new("IAsyncOperationWithProgress`2", WindowsFoundation, "IAsyncOperationWithProgress`2")); - Add(WindowsFoundation, new("IAsyncOperation`1", WindowsFoundation, "IAsyncOperation`1")); - Add(WindowsFoundation, new("IClosable", "System", "IDisposable", true, true)); - Add(WindowsFoundation, new("IMemoryBufferReference", WindowsFoundation, "IMemoryBufferReference")); - Add(WindowsFoundation, new("IPropertyValue", WindowsFoundation, "IPropertyValue", true)); - Add(WindowsFoundation, new("IReferenceArray`1", WindowsFoundation, "IReferenceArray", true)); - Add(WindowsFoundation, new(IReferenceGeneric, "System", NullableGeneric, true)); - Add(WindowsFoundation, new("IStringable", WindowsFoundation, "IStringable")); - Add(WindowsFoundation, new("Point", WindowsFoundation, "Point")); - Add(WindowsFoundation, new("PropertyType", WindowsFoundation, "PropertyType")); - Add(WindowsFoundation, new("Rect", WindowsFoundation, "Rect")); - Add(WindowsFoundation, new("Size", WindowsFoundation, "Size")); - Add(WindowsFoundation, new("TimeSpan", "System", "TimeSpan", true)); - Add(WindowsFoundation, new("TypedEventHandler`2", "System", "EventHandler`2", false)); - Add(WindowsFoundation, new("UniversalApiContract", WindowsFoundation, "UniversalApiContract")); - Add(WindowsFoundation, new("Uri", "System", "Uri", true)); - - // Windows.Foundation.Collections - Add(WindowsFoundationCollections, new("CollectionChange", WindowsFoundationCollections, "CollectionChange")); - Add(WindowsFoundationCollections, new("IIterable`1", "System.Collections.Generic", "IEnumerable`1", true, true)); - Add(WindowsFoundationCollections, new("IIterator`1", "System.Collections.Generic", "IEnumerator`1", true, true)); - Add(WindowsFoundationCollections, new("IKeyValuePair`2", "System.Collections.Generic", "KeyValuePair`2", true)); - Add(WindowsFoundationCollections, new("IMapChangedEventArgs`1", WindowsFoundationCollections, "IMapChangedEventArgs`1")); - Add(WindowsFoundationCollections, new("IMapView`2", "System.Collections.Generic", "IReadOnlyDictionary`2", true, true)); - Add(WindowsFoundationCollections, new("IMap`2", "System.Collections.Generic", "IDictionary`2", true, true)); - Add(WindowsFoundationCollections, new("IObservableMap`2", WindowsFoundationCollections, "IObservableMap`2")); - Add(WindowsFoundationCollections, new("IObservableVector`1", WindowsFoundationCollections, "IObservableVector`1")); - Add(WindowsFoundationCollections, new("IVectorChangedEventArgs", WindowsFoundationCollections, "IVectorChangedEventArgs")); - Add(WindowsFoundationCollections, new("IVectorView`1", "System.Collections.Generic", "IReadOnlyList`1", true, true)); - Add(WindowsFoundationCollections, new("IVector`1", "System.Collections.Generic", "IList`1", true, true)); - Add(WindowsFoundationCollections, new("MapChangedEventHandler`2", WindowsFoundationCollections, "MapChangedEventHandler`2")); - Add(WindowsFoundationCollections, new("VectorChangedEventHandler`1", WindowsFoundationCollections, "VectorChangedEventHandler`1")); - - // Windows.Foundation.Metadata - Add(WindowsFoundationMetadata, new("ApiContractAttribute", WindowsFoundationMetadata, "ApiContractAttribute")); - Add(WindowsFoundationMetadata, new("AttributeTargets", "System", "AttributeTargets")); - Add(WindowsFoundationMetadata, new("AttributeUsageAttribute", "System", "AttributeUsageAttribute")); - Add(WindowsFoundationMetadata, new(ContractVersionAttribute, WindowsFoundationMetadata, ContractVersionAttribute)); - - // Windows.Foundation.Numerics - Add("Windows.Foundation.Numerics", new("Matrix3x2", "System.Numerics", "Matrix3x2")); - Add("Windows.Foundation.Numerics", new("Matrix4x4", "System.Numerics", "Matrix4x4")); - Add("Windows.Foundation.Numerics", new("Plane", "System.Numerics", "Plane")); - Add("Windows.Foundation.Numerics", new("Quaternion", "System.Numerics", "Quaternion")); - Add("Windows.Foundation.Numerics", new("Vector2", "System.Numerics", "Vector2")); - Add("Windows.Foundation.Numerics", new("Vector3", "System.Numerics", "Vector3")); - Add("Windows.Foundation.Numerics", new("Vector4", "System.Numerics", "Vector4")); - - // Windows.Storage.Streams - Add("Windows.Storage.Streams", new("IBuffer", "Windows.Storage.Streams", "IBuffer")); - Add("Windows.Storage.Streams", new("IInputStream", "Windows.Storage.Streams", "IInputStream")); - Add("Windows.Storage.Streams", new("IOutputStream", "Windows.Storage.Streams", "IOutputStream")); - Add("Windows.Storage.Streams", new("IRandomAccessStream", "Windows.Storage.Streams", "IRandomAccessStream")); - Add("Windows.Storage.Streams", new("InputStreamOptions", "Windows.Storage.Streams", "InputStreamOptions")); - - // Windows.UI.Xaml - Add("Windows.UI.Xaml", new("CornerRadius", "Windows.UI.Xaml", "CornerRadius", false, false, true)); - Add("Windows.UI.Xaml", new("CornerRadiusHelper", "", "")); - Add("Windows.UI.Xaml", new("Duration", "Windows.UI.Xaml", "Duration", false, false, true)); - Add("Windows.UI.Xaml", new("DurationHelper", "", "")); - Add("Windows.UI.Xaml", new("GridLength", "Windows.UI.Xaml", "GridLength", false, false, true)); - Add("Windows.UI.Xaml", new("GridLengthHelper", "", "")); - Add("Windows.UI.Xaml", new("ICornerRadiusHelper", "", "")); - Add("Windows.UI.Xaml", new("ICornerRadiusHelperStatics", "", "")); - Add("Windows.UI.Xaml", new("IDurationHelper", "", "")); - Add("Windows.UI.Xaml", new("IDurationHelperStatics", "", "")); - Add("Windows.UI.Xaml", new("IGridLengthHelper", "", "")); - Add("Windows.UI.Xaml", new("IGridLengthHelperStatics", "", "")); - Add("Windows.UI.Xaml", new("IThicknessHelper", "", "")); - Add("Windows.UI.Xaml", new("IThicknessHelperStatics", "", "")); - Add("Windows.UI.Xaml", new("IXamlServiceProvider", "System", "IServiceProvider")); - Add("Windows.UI.Xaml", new("ThicknessHelper", "", "")); - - // Windows.UI.Xaml.Controls.Primitives - Add("Windows.UI.Xaml.Controls.Primitives", new("GeneratorPositionHelper", "", "")); - Add("Windows.UI.Xaml.Controls.Primitives", new("IGeneratorPositionHelper", "", "")); - Add("Windows.UI.Xaml.Controls.Primitives", new("IGeneratorPositionHelperStatics", "", "")); - - // Windows.UI.Xaml.Data - Add("Windows.UI.Xaml.Data", new("DataErrorsChangedEventArgs", "System.ComponentModel", "DataErrorsChangedEventArgs")); - Add("Windows.UI.Xaml.Data", new("INotifyDataErrorInfo", "System.ComponentModel", "INotifyDataErrorInfo", true, true)); - Add("Windows.UI.Xaml.Data", new("INotifyPropertyChanged", "System.ComponentModel", "INotifyPropertyChanged")); - Add("Windows.UI.Xaml.Data", new("PropertyChangedEventArgs", "System.ComponentModel", "PropertyChangedEventArgs")); - Add("Windows.UI.Xaml.Data", new("PropertyChangedEventHandler", "System.ComponentModel", "PropertyChangedEventHandler")); - - // Windows.UI.Xaml.Input - Add("Windows.UI.Xaml.Input", new("ICommand", "System.Windows.Input", "ICommand", true)); - - // Windows.UI.Xaml.Interop - Add(WindowsUIXamlInterop, new("IBindableIterable", "System.Collections", "IEnumerable", true, true)); - Add(WindowsUIXamlInterop, new("IBindableIterator", "System.Collections", "IEnumerator", true, true)); - Add(WindowsUIXamlInterop, new("IBindableVector", "System.Collections", "IList", true, true)); - Add(WindowsUIXamlInterop, new("INotifyCollectionChanged", "System.Collections.Specialized", "INotifyCollectionChanged", true)); - Add(WindowsUIXamlInterop, new("NotifyCollectionChangedAction", "System.Collections.Specialized", "NotifyCollectionChangedAction")); - Add(WindowsUIXamlInterop, new("NotifyCollectionChangedEventArgs", "System.Collections.Specialized", "NotifyCollectionChangedEventArgs", true)); - Add(WindowsUIXamlInterop, new("NotifyCollectionChangedEventHandler", "System.Collections.Specialized", "NotifyCollectionChangedEventHandler", true)); - Add(WindowsUIXamlInterop, new("TypeKind", WindowsUIXamlInterop, "TypeKind", true)); - Add(WindowsUIXamlInterop, new(TypeName, "System", "Type", true)); - - // Windows.UI.Xaml.Media - Add("Windows.UI.Xaml.Media", new("IMatrixHelper", "", "")); - Add("Windows.UI.Xaml.Media", new("IMatrixHelperStatics", "", "")); - Add("Windows.UI.Xaml.Media", new("MatrixHelper", "", "")); - - // Windows.UI.Xaml.Media.Animation - Add("Windows.UI.Xaml.Media.Animation", new("IKeyTimeHelper", "", "")); - Add("Windows.UI.Xaml.Media.Animation", new("IKeyTimeHelperStatics", "", "")); - Add("Windows.UI.Xaml.Media.Animation", new("IRepeatBehaviorHelper", "", "")); - Add("Windows.UI.Xaml.Media.Animation", new("IRepeatBehaviorHelperStatics", "", "")); - Add("Windows.UI.Xaml.Media.Animation", new("KeyTime", "Windows.UI.Xaml.Media.Animation", "KeyTime", false, false, true)); - Add("Windows.UI.Xaml.Media.Animation", new("KeyTimeHelper", "", "")); - Add("Windows.UI.Xaml.Media.Animation", new("RepeatBehavior", "Windows.UI.Xaml.Media.Animation", "RepeatBehavior", false, false, true)); - Add("Windows.UI.Xaml.Media.Animation", new("RepeatBehaviorHelper", "", "")); - - // Windows.UI.Xaml.Media.Media3D - Add("Windows.UI.Xaml.Media.Media3D", new("IMatrix3DHelper", "", "")); - Add("Windows.UI.Xaml.Media.Media3D", new("IMatrix3DHelperStatics", "", "")); - Add("Windows.UI.Xaml.Media.Media3D", new("Matrix3D", "Windows.UI.Xaml.Media.Media3D", "Matrix3D", false, false, true)); - Add("Windows.UI.Xaml.Media.Media3D", new("Matrix3DHelper", "", "")); - - // WindowsRuntime.Internal - Add(WindowsRuntimeInternal, new("HWND", "System", "IntPtr")); - Add(WindowsRuntimeInternal, new("ProjectionInternalAttribute", "", "")); - - Dictionary> frozenInner = []; - foreach (KeyValuePair> kvp in result) - { - frozenInner[kvp.Key] = kvp.Value.ToFrozenDictionary(); - } - return frozenInner.ToFrozenDictionary(); - } } \ No newline at end of file From 11f2889da1e1c533a079af30cc75c6741c4f79b1 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 13:59:35 -0700 Subject: [PATCH 106/171] Refactor ContractPlatforms to TryGetPlatform Replace GetPlatform that returned empty strings with a TryGetPlatform(bool) pattern and an out platform parameter, improving nullability and call-site clarity. Initialize the contract/version table inline (removing the Build helper), add NotNullWhen annotations and XML docs, and update CustomAttributeFactory to use the new TryGetPlatform API. --- .../Factories/CustomAttributeFactory.cs | 4 +- .../Helpers/ContractPlatforms.cs | 175 +++++++++--------- 2 files changed, 92 insertions(+), 87 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index d7eabd891..8dbb058a1 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -247,9 +247,7 @@ private static string GetPlatform(ProjectionEmitContext context, CustomAttribute }; int contractVersion = (int)(versionRaw >> 16); - string platform = ContractPlatforms.GetPlatform(contractName, contractVersion); - - if (string.IsNullOrEmpty(platform)) + if (!ContractPlatforms.TryGetPlatform(contractName, contractVersion, out string? platform)) { return string.Empty; } diff --git a/src/WinRT.Projection.Writer/Helpers/ContractPlatforms.cs b/src/WinRT.Projection.Writer/Helpers/ContractPlatforms.cs index d4667a180..dea2f9eaa 100644 --- a/src/WinRT.Projection.Writer/Helpers/ContractPlatforms.cs +++ b/src/WinRT.Projection.Writer/Helpers/ContractPlatforms.cs @@ -1,9 +1,9 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using System; using System.Collections.Frozen; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -12,105 +12,112 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; /// internal static class ContractPlatforms { - private static readonly FrozenDictionary Table = Build(); + /// + /// The mapping of all platforms and contract versions. + /// + private static readonly FrozenDictionary Table = new Dictionary + { + ["Windows.AI.MachineLearning.MachineLearningContract"] = + [(1, "10.0.17763.0"), (2, "10.0.18362.0"), (3, "10.0.19041.0"), (4, "10.0.20348.0"), (5, "10.0.22000.0")], + ["Windows.AI.MachineLearning.Preview.MachineLearningPreviewContract"] = + [(1, "10.0.17134.0"), (2, "10.0.17763.0")], + ["Windows.ApplicationModel.Calls.Background.CallsBackgroundContract"] = + [(1, "10.0.17763.0"), (2, "10.0.18362.0"), (3, "10.0.20348.0"), (4, "10.0.22621.0")], + ["Windows.ApplicationModel.Calls.CallsPhoneContract"] = + [(4, "10.0.17763.0"), (5, "10.0.18362.0"), (6, "10.0.20348.0"), (7, "10.0.22621.0")], + ["Windows.ApplicationModel.Calls.CallsVoipContract"] = + [(1, "10.0.10586.0"), (2, "10.0.16299.0"), (3, "10.0.17134.0"), (4, "10.0.17763.0"), (5, "10.0.26100.0")], + ["Windows.ApplicationModel.CommunicationBlocking.CommunicationBlockingContract"] = + [(2, "10.0.17763.0")], + ["Windows.ApplicationModel.SocialInfo.SocialInfoContract"] = + [(1, "10.0.14393.0"), (2, "10.0.15063.0")], + ["Windows.ApplicationModel.StartupTaskContract"] = + [(2, "10.0.16299.0"), (3, "10.0.17134.0")], + ["Windows.Devices.Custom.CustomDeviceContract"] = + [(1, "10.0.16299.0")], + ["Windows.Devices.DevicesLowLevelContract"] = + [(2, "10.0.14393.0"), (3, "10.0.15063.0")], + ["Windows.Devices.Printers.PrintersContract"] = + [(1, "10.0.10586.0")], + ["Windows.Devices.SmartCards.SmartCardBackgroundTriggerContract"] = + [(3, "10.0.16299.0")], + ["Windows.Devices.SmartCards.SmartCardEmulatorContract"] = + [(5, "10.0.16299.0"), (6, "10.0.17763.0")], + ["Windows.Foundation.FoundationContract"] = + [(1, "10.0.10240.0"), (2, "10.0.10586.0"), (3, "10.0.15063.0"), (4, "10.0.19041.0")], + ["Windows.Foundation.UniversalApiContract"] = + [(1, "10.0.10240.0"), (2, "10.0.10586.0"), (3, "10.0.14393.0"), (4, "10.0.15063.0"), (5, "10.0.16299.0"), + (6, "10.0.17134.0"), (7, "10.0.17763.0"), (8, "10.0.18362.0"), (10, "10.0.19041.0"), (12, "10.0.20348.0"), + (14, "10.0.22000.0"), (15, "10.0.22621.0"), (19, "10.0.26100.0")], + ["Windows.Foundation.VelocityIntegration.VelocityIntegrationContract"] = + [(1, "10.0.17134.0")], + ["Windows.Gaming.XboxLive.StorageApiContract"] = + [(1, "10.0.16299.0")], + ["Windows.Graphics.Printing3D.Printing3DContract"] = + [(2, "10.0.10586.0"), (3, "10.0.14393.0"), (4, "10.0.16299.0")], + ["Windows.Networking.Connectivity.WwanContract"] = + [(1, "10.0.10240.0"), (2, "10.0.17134.0"), (3, "10.0.26100.0")], + ["Windows.Networking.Sockets.ControlChannelTriggerContract"] = + [(3, "10.0.17763.0")], + ["Windows.Security.Isolation.IsolatedWindowsEnvironmentContract"] = + [(1, "10.0.19041.0"), (3, "10.0.20348.0"), (4, "10.0.22621.0"), (5, "10.0.26100.0")], + ["Windows.Services.Maps.GuidanceContract"] = + [(3, "10.0.17763.0")], + ["Windows.Services.Maps.LocalSearchContract"] = + [(4, "10.0.17763.0")], + ["Windows.Services.Store.StoreContract"] = + [(1, "10.0.14393.0"), (2, "10.0.15063.0"), (3, "10.0.17134.0"), (4, "10.0.17763.0")], + ["Windows.Services.TargetedContent.TargetedContentContract"] = + [(1, "10.0.15063.0")], + ["Windows.Storage.Provider.CloudFilesContract"] = + [(4, "10.0.19041.0"), (6, "10.0.20348.0"), (7, "10.0.22621.0")], + ["Windows.System.Profile.ProfileHardwareTokenContract"] = + [(1, "10.0.14393.0")], + ["Windows.System.Profile.ProfileRetailInfoContract"] = + [(1, "10.0.20348.0")], + ["Windows.System.Profile.ProfileSharedModeContract"] = + [(1, "10.0.14393.0"), (2, "10.0.15063.0")], + ["Windows.System.Profile.SystemManufacturers.SystemManufacturersContract"] = + [(3, "10.0.17763.0")], + ["Windows.System.SystemManagementContract"] = + [(6, "10.0.17763.0"), (7, "10.0.19041.0")], + ["Windows.UI.UIAutomation.UIAutomationContract"] = + [(1, "10.0.20348.0"), (2, "10.0.22000.0")], + ["Windows.UI.ViewManagement.ViewManagementViewScalingContract"] = + [(1, "10.0.14393.0")], + ["Windows.UI.Xaml.Core.Direct.XamlDirectContract"] = + [(1, "10.0.17763.0"), (2, "10.0.18362.0"), (3, "10.0.20348.0"), (5, "10.0.22000.0")], + }.ToFrozenDictionary(); /// /// Returns the platform version (e.g., "10.0.17763.0") that introduced the given contract version, /// or empty string if not found. /// - public static string GetPlatform(string contractName, int contractVersion) + /// The contract name to use. + /// The contract version to use. + /// The resulting platform, if found. + public static bool TryGetPlatform(string contractName, int contractVersion, [NotNullWhen(true)] out string? platform) { if (!Table.TryGetValue(contractName, out (int Version, string Platform)[]? versions)) { - return string.Empty; + platform = null; + + return false; } - // Find the first version >= contractVersion. + // Find the first version greater than the input contract version for (int i = 0; i < versions.Length; i++) { if (versions[i].Version >= contractVersion) { - return versions[i].Platform; + platform = versions[i].Platform; + + return true; } } - return string.Empty; - } - private static FrozenDictionary Build() - { - Dictionary t = new(StringComparer.Ordinal) - { - ["Windows.AI.MachineLearning.MachineLearningContract"] = - [(1, "10.0.17763.0"), (2, "10.0.18362.0"), (3, "10.0.19041.0"), (4, "10.0.20348.0"), (5, "10.0.22000.0")], - ["Windows.AI.MachineLearning.Preview.MachineLearningPreviewContract"] = - [(1, "10.0.17134.0"), (2, "10.0.17763.0")], - ["Windows.ApplicationModel.Calls.Background.CallsBackgroundContract"] = - [(1, "10.0.17763.0"), (2, "10.0.18362.0"), (3, "10.0.20348.0"), (4, "10.0.22621.0")], - ["Windows.ApplicationModel.Calls.CallsPhoneContract"] = - [(4, "10.0.17763.0"), (5, "10.0.18362.0"), (6, "10.0.20348.0"), (7, "10.0.22621.0")], - ["Windows.ApplicationModel.Calls.CallsVoipContract"] = - [(1, "10.0.10586.0"), (2, "10.0.16299.0"), (3, "10.0.17134.0"), (4, "10.0.17763.0"), (5, "10.0.26100.0")], - ["Windows.ApplicationModel.CommunicationBlocking.CommunicationBlockingContract"] = - [(2, "10.0.17763.0")], - ["Windows.ApplicationModel.SocialInfo.SocialInfoContract"] = - [(1, "10.0.14393.0"), (2, "10.0.15063.0")], - ["Windows.ApplicationModel.StartupTaskContract"] = - [(2, "10.0.16299.0"), (3, "10.0.17134.0")], - ["Windows.Devices.Custom.CustomDeviceContract"] = - [(1, "10.0.16299.0")], - ["Windows.Devices.DevicesLowLevelContract"] = - [(2, "10.0.14393.0"), (3, "10.0.15063.0")], - ["Windows.Devices.Printers.PrintersContract"] = - [(1, "10.0.10586.0")], - ["Windows.Devices.SmartCards.SmartCardBackgroundTriggerContract"] = - [(3, "10.0.16299.0")], - ["Windows.Devices.SmartCards.SmartCardEmulatorContract"] = - [(5, "10.0.16299.0"), (6, "10.0.17763.0")], - ["Windows.Foundation.FoundationContract"] = - [(1, "10.0.10240.0"), (2, "10.0.10586.0"), (3, "10.0.15063.0"), (4, "10.0.19041.0")], - ["Windows.Foundation.UniversalApiContract"] = - [(1, "10.0.10240.0"), (2, "10.0.10586.0"), (3, "10.0.14393.0"), (4, "10.0.15063.0"), (5, "10.0.16299.0"), - (6, "10.0.17134.0"), (7, "10.0.17763.0"), (8, "10.0.18362.0"), (10, "10.0.19041.0"), (12, "10.0.20348.0"), - (14, "10.0.22000.0"), (15, "10.0.22621.0"), (19, "10.0.26100.0")], - ["Windows.Foundation.VelocityIntegration.VelocityIntegrationContract"] = - [(1, "10.0.17134.0")], - ["Windows.Gaming.XboxLive.StorageApiContract"] = - [(1, "10.0.16299.0")], - ["Windows.Graphics.Printing3D.Printing3DContract"] = - [(2, "10.0.10586.0"), (3, "10.0.14393.0"), (4, "10.0.16299.0")], - ["Windows.Networking.Connectivity.WwanContract"] = - [(1, "10.0.10240.0"), (2, "10.0.17134.0"), (3, "10.0.26100.0")], - ["Windows.Networking.Sockets.ControlChannelTriggerContract"] = - [(3, "10.0.17763.0")], - ["Windows.Security.Isolation.IsolatedWindowsEnvironmentContract"] = - [(1, "10.0.19041.0"), (3, "10.0.20348.0"), (4, "10.0.22621.0"), (5, "10.0.26100.0")], - ["Windows.Services.Maps.GuidanceContract"] = - [(3, "10.0.17763.0")], - ["Windows.Services.Maps.LocalSearchContract"] = - [(4, "10.0.17763.0")], - ["Windows.Services.Store.StoreContract"] = - [(1, "10.0.14393.0"), (2, "10.0.15063.0"), (3, "10.0.17134.0"), (4, "10.0.17763.0")], - ["Windows.Services.TargetedContent.TargetedContentContract"] = - [(1, "10.0.15063.0")], - ["Windows.Storage.Provider.CloudFilesContract"] = - [(4, "10.0.19041.0"), (6, "10.0.20348.0"), (7, "10.0.22621.0")], - ["Windows.System.Profile.ProfileHardwareTokenContract"] = - [(1, "10.0.14393.0")], - ["Windows.System.Profile.ProfileRetailInfoContract"] = - [(1, "10.0.20348.0")], - ["Windows.System.Profile.ProfileSharedModeContract"] = - [(1, "10.0.14393.0"), (2, "10.0.15063.0")], - ["Windows.System.Profile.SystemManufacturers.SystemManufacturersContract"] = - [(3, "10.0.17763.0")], - ["Windows.System.SystemManagementContract"] = - [(6, "10.0.17763.0"), (7, "10.0.19041.0")], - ["Windows.UI.UIAutomation.UIAutomationContract"] = - [(1, "10.0.20348.0"), (2, "10.0.22000.0")], - ["Windows.UI.ViewManagement.ViewManagementViewScalingContract"] = - [(1, "10.0.14393.0")], - ["Windows.UI.Xaml.Core.Direct.XamlDirectContract"] = - [(1, "10.0.17763.0"), (2, "10.0.18362.0"), (3, "10.0.20348.0"), (5, "10.0.22000.0")], - }; - return t.ToFrozenDictionary(StringComparer.Ordinal); + platform = null; + + return false; } } \ No newline at end of file From 67b76e57e0321ec49e8adf00f687e89544c2cd98 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 14:01:10 -0700 Subject: [PATCH 107/171] Always emit projected structs as partial Remove the AdditionTypes lookup and simplify ProjectionFileBuilder to always write 'partial' on generated struct declarations. Deletions: src/WinRT.Projection.Writer/Helpers/AdditionTypes.cs; Changes: ProjectionFileBuilder now unconditionally emits "public partial struct " and includes a comment explaining the rationale (so custom additions can extend types without special-casing). This simplifies generation by removing the metadata-based presence check. --- .../Builders/ProjectionFileBuilder.cs | 7 ++-- .../Helpers/AdditionTypes.cs | 41 ------------------- 2 files changed, 4 insertions(+), 44 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Helpers/AdditionTypes.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 05bc803fe..493ccf0c3 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -173,7 +173,6 @@ private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext } string projectionName = type.Name?.Value ?? string.Empty; - bool hasAddition = AdditionTypes.HasAdditionToType(type.Namespace?.Value ?? string.Empty, projectionName); // Header attributes + struct declaration as a single multiline template. WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); @@ -182,14 +181,16 @@ private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); WriteWinRTReferenceTypeAttributeCallback refTypeAttr = MetadataAttributeFactory.WriteWinRTReferenceTypeAttribute(context, type); - string partial = hasAddition ? " partial" : ""; + // We are generating all types as 'partial' so that if they have any + // custom additions, they can be added without issues. This is much + // simpler than having logic to check that (the metadata is the same). writer.WriteLine(isMultiline: true, $$""" {{metadataAttr}} {{valueTypeAttr}} {{customAttrs}} {{comWrappersAttr}} {{refTypeAttr}} - public{{partial}} struct {{projectionName}} : IEquatable<{{projectionName}}> + public partial struct {{projectionName}} : IEquatable<{{projectionName}}> """); using (writer.WriteBlock()) diff --git a/src/WinRT.Projection.Writer/Helpers/AdditionTypes.cs b/src/WinRT.Projection.Writer/Helpers/AdditionTypes.cs deleted file mode 100644 index 7162940aa..000000000 --- a/src/WinRT.Projection.Writer/Helpers/AdditionTypes.cs +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using System; -using System.Collections.Frozen; -using System.Collections.Generic; - -namespace WindowsRuntime.ProjectionWriter.Helpers; - -/// -/// Static lookup for the (namespace, type-name) pairs that have an associated namespace-additions -/// resource. Used by the projected-struct emitter to decide whether the struct should be projected -/// as partial (so the addition file's content can extend it). -/// -internal static class AdditionTypes -{ - private static readonly FrozenDictionary> Table = new Dictionary>(StringComparer.Ordinal) - { - ["Microsoft.UI.Xaml"] = FrozenSet.Create(StringComparer.Ordinal, "Thickness"), - ["Microsoft.UI.Xaml.Controls.Primitives"] = FrozenSet.Create(StringComparer.Ordinal, "GeneratorPosition"), - ["Microsoft.UI.Xaml.Media"] = FrozenSet.Create(StringComparer.Ordinal, "Matrix"), - ["Microsoft.UI.Xaml.Media.Animation"] = FrozenSet.Create(StringComparer.Ordinal, "KeyTime"), - ["Windows.UI"] = FrozenSet.Create(StringComparer.Ordinal, "Color"), - ["Windows.UI.Xaml"] = FrozenSet.Create(StringComparer.Ordinal, "Thickness"), - ["Windows.UI.Xaml.Controls.Primitives"] = FrozenSet.Create(StringComparer.Ordinal, "GeneratorPosition"), - ["Windows.UI.Xaml.Media"] = FrozenSet.Create(StringComparer.Ordinal, "Matrix"), - ["Windows.UI.Xaml.Media.Animation"] = FrozenSet.Create(StringComparer.Ordinal, "KeyTime"), - }.ToFrozenDictionary(StringComparer.Ordinal); - - /// - /// Returns whether the type identified by (, ) - /// has an associated namespace-additions resource. - /// - /// The type's namespace. - /// The type's short name (without generic arity). - /// if an addition exists; otherwise . - public static bool HasAdditionToType(string typeNamespace, string typeName) - { - return Table.TryGetValue(typeNamespace, out FrozenSet? names) && names.Contains(typeName); - } -} From b3983a940f65c430c85257e78283bf2cdf14a184 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 14:27:05 -0700 Subject: [PATCH 108/171] Tidy AbiClassFactory generic-instance flow + Dispose whitespace MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit **`AbiClassFactory.WriteClassMarshallerInternal`** (3 tweaks): - Default-interface generic-instance detection now uses the `ITypeDefOrRef.TryGetGenericInstance` extension (introduced as R7-27) instead of the open-coded `is TypeSpecification && Signature is GenericInstanceTypeSignature` pattern. - `ObjRefNameGenerator.EmitUnsafeAccessorForIid` is now called directly with the writer (it indents itself), replacing the previous awkward "format to string, split by '\n', re-emit with manual prefix" loop. - Empty file-scoped marshaller stub uses the C# 12+ semicolon body form: `file static class X;` (no observable difference in current scenarios — this codepath isn't exercised by the standard SDK / WinUI / PushNotifications inputs — but the form is now consistent with other empty type declarations). **`MappedInterfaceStubFactory.WriteIBindableIteratorStub`**: - Style fix on the emitted enumerator stub: `public void Dispose() {}` → `public void Dispose() { }` (consistent with the rest of the generated emissions, which all use the space-padded empty-body convention). Validation: ran all three scenarios against a fresh pre-tweak baseline. The 5 output diffs detected across pushnot/evwithui/windows are all exactly the intentional `Dispose() { }` whitespace change; no other unintended deltas. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiClassFactory.cs | 27 ++++++++----------- .../Factories/MappedInterfaceStubFactory.cs | 2 +- 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index c21a8f4a9..775f2e4ae 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -53,24 +53,24 @@ internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, Pr string projectedType = $"global::{typeNs}.{nameStripped}"; ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); + // If the default interface is a generic instantiation (e.g. IDictionary), emit an // UnsafeAccessor extern declaration inside ConvertToUnmanaged that fetches the IID via // WinRT.Interop's InterfaceIIDs class (since the IID for a generic instantiation is computed // at runtime). The IID expression in the call then becomes '(null)' instead of a // static InterfaceIIDs reference. - GenericInstanceTypeSignature? defaultGenericInst = null; - - if (defaultIface is TypeSpecification spec - && spec.Signature is GenericInstanceTypeSignature gi) + if (defaultIface?.TryGetGenericInstance(out GenericInstanceTypeSignature? defaultGenericInst) is not true) { - defaultGenericInst = gi; + defaultGenericInst = null; } string defaultIfaceIid; + // If the type is generic, we need to invoke the unsafe accessor (because the IID will be generated + // in the 'WinRT.Interop.dll' assembly, whereas if not we can directly use the local IID property. if (defaultGenericInst is not null) { - // Call the accessor: '>(null)'. + // Call the accessor: '>(null)' string accessorName = ObjRefNameGenerator.BuildIidPropertyNameForGenericInterface(context, defaultGenericInst); defaultIfaceIid = accessorName + "(null)"; } @@ -88,17 +88,12 @@ public static unsafe class {{nameStripped}}Marshaller public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedType}} value) { """); + + // Emit the '[UnsafeAccessor]' declaration (uses 'object?' since component-mode + // marshallers run inside #nullable enable) if the type is a generic type. if (defaultGenericInst is not null) { - // Emit the UnsafeAccessor declaration (uses 'object?' since component-mode - // marshallers run inside #nullable enable). - string accessorBlock = ObjRefNameGenerator.EmitUnsafeAccessorForIid(context, defaultGenericInst, isInNullableContext: true); - // Re-emit each line indented by 8 spaces. - string[] accessorLines = accessorBlock.TrimEnd('\n').Split('\n'); - foreach (string accessorLine in accessorLines) - { - writer.WriteLine($" {accessorLine}"); - } + ObjRefNameGenerator.EmitUnsafeAccessorForIid(writer, context, defaultGenericInst, isInNullableContext: true); } writer.WriteLine(isMultiline: true, $$""" @@ -148,7 +143,7 @@ internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, Proje writer.WriteLine(isMultiline: true, $$""" [WindowsRuntimeMetadataTypeName("{{fullName}}")] [WindowsRuntimeMappedType(typeof({{projectedType}}))] - file static class {{nameStripped}} {} + file static class {{nameStripped}}; """); } diff --git a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs index 8b47b85e2..98c1e8374 100644 --- a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs @@ -167,7 +167,7 @@ private static void EmitGenericEnumerator(IndentedTextWriter writer, ProjectionE writer.WriteLine(isMultiline: true, $$""" public bool MoveNext() => {{prefix}}MoveNext(null, {{objRefName}}); public void Reset() => throw new NotSupportedException(); - public void Dispose() {} + public void Dispose() { } public {{t}} Current => {{prefix}}Current(null, {{objRefName}}); object global::System.Collections.IEnumerator.Current => Current!; """); From 6179b59696688c8fa5d736a195761fa09b1f98a4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 14:40:59 -0700 Subject: [PATCH 109/171] Unify SZ-array element type-name ladders via AbiTypeHelpers helpers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `EmitAbiMethodBodyIfSimple` (and the matching DoAbi paths) contained five nested-ternary chains computing storage / element-ABI / data-param types for SZ-array marshalling, plus two existing R7-12 `switch` expressions in the same family. All of them dispatched off the array element type but with subtle per-site differences in coverage (some omitted the HResult or MappedValueType branches, falling through to a default), which is brittle. Add two unified helpers to `AbiTypeHelpers.AbiTypeNames.cs`, both built on the existing `AbiTypeShapeResolver.ClassifyArrayElement` (R7-12) discriminator: - **`GetArrayElementAbiType(context, elementType)`**: returns the single `T` name used in the `data` parameter of `ConvertToManaged_X` / `Free_X` / `CopyToManaged_X` / `CopyToUnmanaged_X` / function-pointer signatures (`void*` / `Exception` / mapped / struct / blittable / primitive). Used directly for one-pointer slots, and with inline `"{T}* data"` / `"({T}*)"` construction at sites that need a full pointer parameter + matching cast. - **`GetArrayElementStorageType(context, elementType)`**: returns the `T` name used in `InlineArray16` / `ArrayPool` storage backing non-blittable PassArray / FillArray parameters (mapped / struct → ABI struct; HResult → `Exception`; everything else → `nint`). **Cleanup of unused `writer` parameter:** `GetAbiLocalTypeName`, `GetArrayElementAbiType`, `GetArrayElementStorageType`, `GetBlittableStructAbiType`, and `GetAbiStructTypeName` previously accepted an `IndentedTextWriter` arg that none of them actually used. The arg was only forwarded transitively to the struct-name helpers `GetAbiStructTypeName` / `GetBlittableStructAbiType`, where it was also unused (the body inspected only `context`/`sig`). Dropped the parameter throughout and updated all 29 call sites accordingly. The misleading XML doc on `GetAbiStructTypeName` (which claimed the writer position controlled qualified vs short-name output — never true) was also corrected. **Migrated sites:** - `RcwCaller.cs`: 5 nested-ternary chains (`storageT`, two `elementAbi`, `poolStorageT`, return-side `elementAbi`) replaced with helper calls. - `RcwCaller.cs`: 2 existing R7-12 `switch` expressions (parameter-side + return-side fp signature builders) replaced with `GetArrayElementAbiType`. - `RcwCaller.cs` + `DoAbi.cs`: 2 instances of the 4-way data-param / data-cast if/else-if ladders replaced with `GetArrayElementAbiType` + inline `"{T}* data"` / `"({T}*)"` construction. Note: a couple of the migrated sites had narrower (4-way / 3-way) ladders that didn't enumerate all 6 cases — for those, the unified helper widens coverage. Validation confirms the broader cases aren't reached in any of our scenarios (byte-identical output), but the helpers now express the intent correctly should those inputs ever surface. Validation: 763/763 byte-identical across pushnot/evwithui/windows; build 0/0. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 46 +---- .../AbiMethodBodyFactory.RcwCaller.cs | 161 ++++-------------- .../Factories/ReferenceImplFactory.cs | 2 +- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 81 +++++++-- 4 files changed, 113 insertions(+), 177 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 36326bafe..8ad72f2b8 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -12,8 +12,6 @@ using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; -using WindowsRuntime.ProjectionWriter.References; - namespace WindowsRuntime.ProjectionWriter.Factories; internal static partial class AbiMethodBodyFactory @@ -114,7 +112,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); - string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, sza.BaseType); + string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, sza.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern void ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); @@ -125,7 +123,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (returnIsReceiveArrayDoAbi && rt is SzArrayTypeSignature retSzHoist) { WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSzHoist.BaseType)); - string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, retSzHoist.BaseType); + string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, retSzHoist.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(retSzHoist.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] @@ -283,7 +281,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) { - string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType); + string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); dataParamType = abiStructName + "* data"; dataCastExpr = "(" + abiStructName + "*)" + ptr; } @@ -532,41 +530,15 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); - // Determine the ABI element type for the data pointer cast. - // - Strings / runtime classes / objects: void** - // - HResult exception: global::ABI.System.Exception* - // - Mapped value types (DateTime/TimeSpan): global::ABI.System.{DateTimeOffset/TimeSpan}* - // - Complex structs: * - string dataParamType; - string dataCastType; - - if (szFA.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) - { - dataParamType = "void** data"; - dataCastType = "(void**)"; - } - else if (szFA.BaseType.IsHResultException()) - { - dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointerData; - dataCastType = "(global::ABI.System.Exception*)"; - } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(szFA.BaseType)) - { - string abiName = AbiTypeHelpers.GetMappedAbiTypeName(szFA.BaseType); - dataParamType = abiName + "* data"; - dataCastType = "(" + abiName + "*)"; - } - else - { - string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, szFA.BaseType); - dataParamType = abiStructName + "* data"; - dataCastType = "(" + abiStructName + "*)"; - } + // Determine the ABI element type for the data pointer cast (e.g. "void*" for + // ref-like elements -> "void** data"/"(void**)", or "global::ABI.Foo.Bar" for + // complex structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). + string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{dataParamType}}); - CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, {{dataCastType}}{{ptr}}); + static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{elementAbi}}* data); + CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, ({{elementAbi}}*){{ptr}}); """); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 51152838a..8a2f8c84a 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -77,11 +77,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) { - _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(writer, context, uOut)); _ = fp.Append('*'); + _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, uOut)); _ = fp.Append('*'); } else if (context.AbiTypeShapeResolver.IsBlittableStruct(uOut)) { - _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, uOut)); _ = fp.Append('*'); + _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, uOut)); _ = fp.Append('*'); } else { @@ -98,11 +98,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (context.AbiTypeShapeResolver.IsComplexStruct(uRef)) { - _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(writer, context, uRef)); _ = fp.Append('*'); + _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, uRef)); _ = fp.Append('*'); } else if (context.AbiTypeShapeResolver.IsBlittableStruct(uRef)) { - _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, uRef)); _ = fp.Append('*'); + _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, uRef)); _ = fp.Append('*'); } else { @@ -116,17 +116,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { SzArrayTypeSignature sza = p.Type.AsSzArray()!; _ = fp.Append(", uint*, "); - - _ = fp.Append(context.AbiTypeShapeResolver.ClassifyArrayElement(sza.BaseType) switch - { - AbiArrayElementKind.RefLikeVoidStar => "void*", - AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, - AbiArrayElementKind.MappedValueType => AbiTypeHelpers.GetMappedAbiTypeName(sza.BaseType), - AbiArrayElementKind.ComplexStruct => AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType), - AbiArrayElementKind.BlittableStruct => AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType), - _ => AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType), - }); - + _ = fp.Append(AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType)); _ = fp.Append("**"); continue; } @@ -147,7 +137,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (context.AbiTypeShapeResolver.IsBlittableStruct(p.Type)) { - _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, p.Type)); + _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, p.Type)); } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) { @@ -156,7 +146,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else { _ = fp.Append(context.AbiTypeShapeResolver.IsComplexStruct(p.Type) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, p.Type) + ? AbiTypeHelpers.GetAbiStructTypeName(context, p.Type) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, p.Type)); } } @@ -167,17 +157,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; _ = fp.Append(", uint*, "); - - _ = fp.Append(context.AbiTypeShapeResolver.ClassifyArrayElement(retSz.BaseType) switch - { - AbiArrayElementKind.RefLikeVoidStar => "void*", - AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, - AbiArrayElementKind.MappedValueType => AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType), - AbiArrayElementKind.ComplexStruct => AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType), - AbiArrayElementKind.BlittableStruct => AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType), - _ => AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType), - }); - + _ = fp.Append(AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType)); _ = fp.Append("**"); } else if (returnIsHResultException) @@ -198,11 +178,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (returnIsBlittableStruct) { - _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(writer, context, rt!)); _ = fp.Append('*'); + _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, rt!)); _ = fp.Append('*'); } else if (returnIsComplexStruct) { - _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(writer, context, rt!)); _ = fp.Append('*'); + _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, rt!)); _ = fp.Append('*'); } else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) { @@ -323,7 +303,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } string localName = p.GetParamLocalName(paramNameOverride); - writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(writer, context, pType)} __{localName} = default;"); + writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(context, pType)} __{localName} = default;"); } // Declare locals for Out parameters (need to be passed as &__ to the call). @@ -335,7 +315,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); writer.Write(" "); - string abi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, uOut); + string abi = AbiTypeHelpers.GetAbiLocalTypeName(context, uOut); writer.WriteLine($"{abi} __{localName} = default;"); } @@ -352,7 +332,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec """); // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. - string elemAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, sza.BaseType); + string elemAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, sza.BaseType); writer.WriteLine($"{elemAbi}* __{localName}_data = default;"); } @@ -386,13 +366,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); ArrayTempNames names = new(localName); - string storageT = context.AbiTypeShapeResolver.IsMappedAbiValueType(szArr.BaseType) - ? AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) - : context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType) - : szArr.BaseType.IsHResultException() - ? WellKnownAbiTypeNames.AbiSystemException - : "nint"; + string storageT = AbiTypeHelpers.GetArrayElementStorageType(context, szArr.BaseType); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" Unsafe.SkipInit(out InlineArray16<{{storageT}}> {{names.InlineArray}}); @@ -431,7 +405,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec uint __retval_length = default; """); - string retElemAbi = AbiTypeHelpers.GetAbiLocalTypeName(writer, context, retSz.BaseType); + string retElemAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, retSz.BaseType); writer.WriteLine($"{retElemAbi}* __retval_data = default;"); } else if (returnIsHResultException) @@ -444,11 +418,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (returnIsBlittableStruct) { - writer.WriteLine($" {AbiTypeHelpers.GetBlittableStructAbiType(writer, context, rt!)} __retval = default;"); + writer.WriteLine($" {AbiTypeHelpers.GetBlittableStructAbiType(context, rt!)} __retval = default;"); } else if (returnIsComplexStruct) { - writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(writer, context, rt!)} __retval = default;"); + writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(context, rt!)} __retval = default;"); } else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) { @@ -581,7 +555,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRef = uRefSkip; - string abiType = context.AbiTypeShapeResolver.IsBlittableStruct(uRef) ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, uRef) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uRef); + string abiType = context.AbiTypeShapeResolver.IsBlittableStruct(uRef) ? AbiTypeHelpers.GetBlittableStructAbiType(context, uRef) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uRef); writer.WriteLine($"{indent}{new string(' ', fixedNesting * 4)}fixed({abiType}* _{localName} = &{callName})"); typedFixedCount++; } @@ -760,7 +734,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) { - string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType); + string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); dataParamType = abiStructName + "*"; dataCastType = "(" + abiStructName + "*)"; } @@ -933,41 +907,15 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); ArrayTempNames names = new(localName); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); - // Determine the ABI element type for the data pointer parameter. - // - Strings / runtime classes / objects: void** - // - HResult exception: global::ABI.System.Exception* - // - Mapped value types: global::ABI.System.{DateTimeOffset|TimeSpan}* - // - Complex structs: * - string dataParamType; - string dataCastType; - - if (szFA.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver)) - { - dataParamType = "void** data"; - dataCastType = "(void**)"; - } - else if (szFA.BaseType.IsHResultException()) - { - dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointerData; - dataCastType = "(global::ABI.System.Exception*)"; - } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(szFA.BaseType)) - { - string abiName = AbiTypeHelpers.GetMappedAbiTypeName(szFA.BaseType); - dataParamType = abiName + "* data"; - dataCastType = "(" + abiName + "*)"; - } - else - { - string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, szFA.BaseType); - dataParamType = abiStructName + "* data"; - dataCastType = "(" + abiStructName + "*)"; - } + // Determine the ABI element type for the data pointer parameter (e.g. "void*" for + // ref-like elements -> "void** data"/"(void**)", or "global::ABI.Foo.Bar" for complex + // structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). + string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] - {{callIndent}}static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); - {{callIndent}}CopyToManaged_{{localName}}(null, (uint){{names.Span}}.Length, {{dataCastType}}_{{localName}}, {{callName}}); + {{callIndent}}static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{elementAbi}}* data, Span<{{elementProjected}}> span); + {{callIndent}}CopyToManaged_{{localName}}(null, (uint){{names.Span}}.Length, ({{elementAbi}}*)_{{localName}}, {{callName}}); """); } @@ -1052,16 +1000,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); - // Element ABI type: void* for ref types (string/runtime class/object); ABI struct - // type for complex structs (e.g. authored BasicStruct); blittable struct ABI for - // blittable structs; primitive ABI otherwise. - string elementAbi = sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) - ? "void*" - : context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType) - : context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType); + // Element ABI type for the `data` parameter (void* for ref types, ABI struct for + // complex structs, blittable struct ABI for blittable structs, primitive ABI otherwise). + string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] @@ -1076,17 +1017,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSz.BaseType)); - string elementAbi = retSz.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) - ? "void*" - : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType) - : retSz.BaseType.IsHResultException() - ? WellKnownAbiTypeNames.AbiSystemException - : context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType) - ? AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType) - : context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType); + string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType); writer.WriteLine(isMultiline: true, $$""" {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] {{callIndent}}static extern {{elementProjected}}[] ConvertToManaged_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); @@ -1306,7 +1237,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) { - string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType); + string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); disposeDataParamType = abiStructName + "*"; fixedPtrType = abiStructName + "*"; disposeCastType = string.Empty; @@ -1334,12 +1265,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // ArrayPool storage type matches the InlineArray storage (mapped ABI value type - // for DateTime/TimeSpan; ABI struct for complex structs; nint otherwise). - string poolStorageT = context.AbiTypeShapeResolver.IsMappedAbiValueType(szArr.BaseType) - ? AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) - : context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, szArr.BaseType) - : "nint"; + // for DateTime/TimeSpan; ABI struct for complex structs; ABI Exception for + // HResult; nint otherwise). Same dispatch as the InlineArray16 setup. + string poolStorageT = AbiTypeHelpers.GetArrayElementStorageType(context, szArr.BaseType); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" if ({{names.ArrayFromPool}} is not null) @@ -1382,15 +1310,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; - // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; - // primitive ABI otherwise. (Same categorization as the ConvertToManaged_ path.) - string elementAbi = sza.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) - ? "void*" - : context.AbiTypeShapeResolver.IsComplexStruct(sza.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, sza.BaseType) - : context.AbiTypeShapeResolver.IsBlittableStruct(sza.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, sza.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, sza.BaseType); + // Element ABI type: same dispatch as the ConvertToManaged_ path. + string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] @@ -1421,17 +1342,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else if (returnIsReceiveArray) { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt!; - string elementAbi = retSz.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) - ? "void*" - : context.AbiTypeShapeResolver.IsComplexStruct(retSz.BaseType) - ? AbiTypeHelpers.GetAbiStructTypeName(writer, context, retSz.BaseType) - : retSz.BaseType.IsHResultException() - ? WellKnownAbiTypeNames.AbiSystemException - : context.AbiTypeShapeResolver.IsMappedAbiValueType(retSz.BaseType) - ? AbiTypeHelpers.GetMappedAbiTypeName(retSz.BaseType) - : context.AbiTypeShapeResolver.IsBlittableStruct(retSz.BaseType) - ? AbiTypeHelpers.GetBlittableStructAbiType(writer, context, retSz.BaseType) - : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, retSz.BaseType); + string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType); writer.WriteLine(isMultiline: true, $$""" [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] static extern void Free_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 7a7d5066d..768a277aa 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -85,7 +85,7 @@ public static int get_Value(void* thisPtr, void* result) // Non-blittable struct: marshal via Marshaller.ConvertToUnmanaged then write the // (ABI) struct value into the result pointer. WriteProjectedSignatureCallback projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); - string abiName = AbiTypeHelpers.GetAbiStructTypeName(writer, context, type.ToTypeSignature()); + string abiName = AbiTypeHelpers.GetAbiStructTypeName(context, type.ToTypeSignature()); writer.WriteLine(isMultiline: true, $$""" public static int get_Value(void* thisPtr, void* result) { diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 45b8b3465..e183b6a4b 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -7,11 +7,11 @@ using WindowsRuntime.ProjectionWriter.Factories; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.References; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; -using WindowsRuntime.ProjectionWriter.References; - namespace WindowsRuntime.ProjectionWriter.Helpers; internal static partial class AbiTypeHelpers @@ -25,11 +25,10 @@ internal static partial class AbiTypeHelpers /// mapped value type (DateTime/TimeSpan/etc.) → mapped ABI name; blittable struct → projected /// name; primitive → fundamental C# keyword. /// - /// The writer (carried through for the struct-name helpers that accept it; not used to emit). /// The active emit context. /// The type signature whose ABI local type name is requested. /// The ABI C# type name as a string (no trailing punctuation). - internal static string GetAbiLocalTypeName(IndentedTextWriter writer, ProjectionEmitContext context, TypeSignature sig) + public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSignature sig) { if (sig.IsAbiRefLike(context.AbiTypeShapeResolver)) { @@ -48,7 +47,7 @@ internal static string GetAbiLocalTypeName(IndentedTextWriter writer, Projection if (context.AbiTypeShapeResolver.IsComplexStruct(sig)) { - return GetAbiStructTypeName(writer, context, sig); + return GetAbiStructTypeName(context, sig); } if (IsMappedAbiValueType(sig)) @@ -58,16 +57,65 @@ internal static string GetAbiLocalTypeName(IndentedTextWriter writer, Projection if (context.AbiTypeShapeResolver.IsBlittableStruct(sig)) { - return GetBlittableStructAbiType(writer, context, sig); + return GetBlittableStructAbiType(context, sig); } return GetAbiPrimitiveType(context.Cache, sig); } /// - /// Returns the ABI type name for a blittable struct (the projected type name). + /// Returns the ABI C# type name for a single SZ-array element appearing as the data + /// parameter in array-marshaller UnsafeAccessor signatures (e.g. ConvertToManaged_X, + /// Free_X). Dispatched by : + /// reference-pointer → void*, HResult → global::ABI.System.Exception, mapped value + /// type → mapped ABI name, complex struct → ABI struct name, blittable struct → blittable ABI + /// struct, primitive → primitive ABI type. + /// + /// The active emit context. + /// The SZ-array element type. + /// The ABI C# type name as a string (no trailing punctuation). + public static string GetArrayElementAbiType(ProjectionEmitContext context, TypeSignature elementType) + { + return context.AbiTypeShapeResolver.ClassifyArrayElement(elementType) switch + { + AbiArrayElementKind.RefLikeVoidStar => "void*", + AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, + AbiArrayElementKind.MappedValueType => GetMappedAbiTypeName(elementType), + AbiArrayElementKind.ComplexStruct => GetAbiStructTypeName(context, elementType), + AbiArrayElementKind.BlittableStruct => GetBlittableStructAbiType(context, elementType), + _ => GetAbiPrimitiveType(context.Cache, elementType), + }; + } + + /// + /// Returns the C# type name used for the InlineArray16<T> / ArrayPool<T> + /// storage T backing a non-blittable PassArray / FillArray parameter. Strings, + /// runtime classes, and objects all collapse to nint (HSTRING handles / IInspectable + /// pointers); HResult uses global::ABI.System.Exception; mapped value types and + /// complex structs use their ABI struct name. + /// + /// The active emit context. + /// The SZ-array element type. + /// The storage C# type name as a string (no trailing punctuation). + public static string GetArrayElementStorageType(ProjectionEmitContext context, TypeSignature elementType) + { + return context.AbiTypeShapeResolver.ClassifyArrayElement(elementType) switch + { + AbiArrayElementKind.MappedValueType => GetMappedAbiTypeName(elementType), + AbiArrayElementKind.ComplexStruct => GetAbiStructTypeName(context, elementType), + AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, + _ => "nint", + }; + } + + /// + /// Returns the ABI type name for a blittable struct (the projected type name; mapped value + /// types like DateTime / TimeSpan return their mapped ABI name instead). /// - internal static string GetBlittableStructAbiType(IndentedTextWriter writer, ProjectionEmitContext context, TypeSignature sig) + /// The active emit context. + /// The blittable struct type signature. + /// The ABI C# type name as a string (no trailing punctuation). + public static string GetBlittableStructAbiType(ProjectionEmitContext context, TypeSignature sig) { // Mapped value types (DateTime/TimeSpan) use the ABI type, not the projected type. if (IsMappedAbiValueType(sig)) @@ -79,11 +127,16 @@ internal static string GetBlittableStructAbiType(IndentedTextWriter writer, Proj return result; } - /// Returns the ABI struct type name for a complex struct (e.g. global::ABI.Windows.Web.Http.HttpProgress). - /// When the writer is currently in the matching ABI namespace, returns just the - /// short type name (e.g. HttpProgress) to mirror the original code which uses the - /// unqualified name in same-namespace contexts. - internal static string GetAbiStructTypeName(IndentedTextWriter writer, ProjectionEmitContext context, TypeSignature sig) + /// + /// Returns the ABI struct type name for a complex struct + /// (e.g. global::ABI.Windows.Web.Http.HttpProgress). Mapped structs route through + /// their mapped namespace+name (e.g. Windows.UI.Xaml.Interop.TypeName → + /// global::ABI.System.Type). + /// + /// The active emit context. + /// The complex struct type signature. + /// The ABI C# type name as a string (no trailing punctuation). + public static string GetAbiStructTypeName(ProjectionEmitContext context, TypeSignature sig) { if (sig is TypeDefOrRefSignature td) { @@ -103,7 +156,7 @@ internal static string GetAbiStructTypeName(IndentedTextWriter writer, Projectio /// /// Returns the C# primitive keyword (e.g. "bool", "int") for an ABI corlib element type, or when is not a primitive. /// - internal static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature sig) + public static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature sig) { if (sig is CorLibTypeSignature corlib) { From 4a4bce1e1316f30c56c33ba4739ceab7374a46ae Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 16:29:51 -0700 Subject: [PATCH 110/171] Refactor Additions lookup and usage Replace the previous All list + LINQ-based grouping with a frozen dictionary of namespace -> resource-name[] and an EnumerateByNamespace(ns) helper. ProjectionGenerator now checks the addition filter first and iterates Additions.EnumerateByNamespace(ns) instead of relying on the grouped lookup. Removed the LINQ dependency and simplified lookups; updated a csproj comment to reflect the new API name. --- .../ProjectionGenerator.Namespace.cs | 4 +- .../Helpers/Additions.cs | 115 ++++++++++++------ .../WinRT.Projection.Writer.csproj | 2 +- 3 files changed, 82 insertions(+), 39 deletions(-) diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index 7d376394a..e89f852a6 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -232,9 +232,9 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe // Phase 4: Custom additions to namespaces _token.ThrowIfCancellationRequested(); - if (Additions.ByNamespace.TryGetValue(ns, out string[]? resourceNames) && _settings.AdditionFilter.Includes(ns)) + if (_settings.AdditionFilter.Includes(ns)) { - foreach (string resName in resourceNames) + foreach (string resName in Additions.EnumerateByNamespace(ns)) { using Stream? stream = typeof(ProjectionWriter).Assembly.GetManifestResourceStream(resName); diff --git a/src/WinRT.Projection.Writer/Helpers/Additions.cs b/src/WinRT.Projection.Writer/Helpers/Additions.cs index e782a1c7d..fc9e31f0a 100644 --- a/src/WinRT.Projection.Writer/Helpers/Additions.cs +++ b/src/WinRT.Projection.Writer/Helpers/Additions.cs @@ -3,7 +3,6 @@ using System.Collections.Frozen; using System.Collections.Generic; -using System.Linq; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -15,43 +14,87 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; internal static class Additions { /// - /// (namespace, embedded-resource-manifest-name) pairs. The manifest-name resolves to a - /// call. + /// Lookup of the embedded-resource manifest names for a given target namespace, in the + /// order they should be appended to the projection of that namespace. Each manifest name + /// resolves to a + /// call. /// - public static readonly IReadOnlyList<(string Namespace, string ResourceName)> All = - [ - ("Microsoft.UI.Dispatching", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Dispatching.Microsoft.UI.Dispatching.DispatcherQueueSynchronizationContext.cs"), - ("Microsoft.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.CornerRadius.cs"), - ("Microsoft.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.Duration.cs"), - ("Microsoft.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.GridLength.cs"), - ("Microsoft.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.SR.cs"), - ("Microsoft.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.Thickness.cs"), - ("Microsoft.UI.Xaml.Controls.Primitives", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Controls.Primitives.Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition.cs"), - ("Microsoft.UI.Xaml.Media", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Microsoft.UI.Xaml.Media.Matrix.cs"), - ("Microsoft.UI.Xaml.Media.Animation", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Animation.Microsoft.UI.Xaml.Media.Animation.KeyTime.cs"), - ("Microsoft.UI.Xaml.Media.Animation", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Animation.Microsoft.UI.Xaml.Media.Animation.RepeatBehavior.cs"), - ("Microsoft.UI.Xaml.Media.Media3D", "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Media3D.Microsoft.UI.Xaml.Media.Media3D.Matrix3D.cs"), - ("Windows.Storage", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.Storage.WindowsRuntimeStorageExtensions.cs"), - ("Windows.UI", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Windows.UI.Color.cs"), - ("Windows.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.System.DispatcherQueueSynchronizationContext.cs"), - ("Windows.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.CornerRadius.cs"), - ("Windows.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.Duration.cs"), - ("Windows.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.GridLength.cs"), - ("Windows.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.SR.cs"), - ("Windows.UI.Xaml", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.Thickness.cs"), - ("Windows.UI.Xaml.Controls.Primitives", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Controls.Primitives.Windows.UI.Xaml.Controls.Primitives.GeneratorPosition.cs"), - ("Windows.UI.Xaml.Media", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Windows.UI.Xaml.Media.Matrix.cs"), - ("Windows.UI.Xaml.Media.Animation", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Animation.Windows.UI.Xaml.Media.Animation.KeyTime.cs"), - ("Windows.UI.Xaml.Media.Animation", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Animation.Windows.UI.Xaml.Media.Animation.RepeatBehavior.cs"), - ("Windows.UI.Xaml.Media.Media3D", "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Media3D.Windows.UI.Xaml.Media.Media3D.Matrix3D.cs"), - ]; + private static readonly FrozenDictionary ByNamespace = new Dictionary + { + ["Microsoft.UI.Dispatching"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Dispatching.Microsoft.UI.Dispatching.DispatcherQueueSynchronizationContext.cs", + ], + ["Microsoft.UI.Xaml"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.CornerRadius.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.Duration.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.GridLength.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.SR.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Microsoft.UI.Xaml.Thickness.cs", + ], + ["Microsoft.UI.Xaml.Controls.Primitives"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Controls.Primitives.Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition.cs", + ], + ["Microsoft.UI.Xaml.Media"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Microsoft.UI.Xaml.Media.Matrix.cs", + ], + ["Microsoft.UI.Xaml.Media.Animation"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Animation.Microsoft.UI.Xaml.Media.Animation.KeyTime.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Animation.Microsoft.UI.Xaml.Media.Animation.RepeatBehavior.cs", + ], + ["Microsoft.UI.Xaml.Media.Media3D"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Microsoft.UI.Xaml.Media.Media3D.Microsoft.UI.Xaml.Media.Media3D.Matrix3D.cs", + ], + ["Windows.Storage"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.Storage.WindowsRuntimeStorageExtensions.cs", + ], + ["Windows.UI"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Windows.UI.Color.cs", + ], + ["Windows.UI.Xaml"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.System.DispatcherQueueSynchronizationContext.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.CornerRadius.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.Duration.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.GridLength.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.SR.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Windows.UI.Xaml.Thickness.cs", + ], + ["Windows.UI.Xaml.Controls.Primitives"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Controls.Primitives.Windows.UI.Xaml.Controls.Primitives.GeneratorPosition.cs", + ], + ["Windows.UI.Xaml.Media"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Windows.UI.Xaml.Media.Matrix.cs", + ], + ["Windows.UI.Xaml.Media.Animation"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Animation.Windows.UI.Xaml.Media.Animation.KeyTime.cs", + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Animation.Windows.UI.Xaml.Media.Animation.RepeatBehavior.cs", + ], + ["Windows.UI.Xaml.Media.Media3D"] = + [ + "WindowsRuntime.ProjectionWriter.Resources.Additions.Windows.UI.Xaml.Media.Media3D.Windows.UI.Xaml.Media.Media3D.Matrix3D.cs", + ], + }.ToFrozenDictionary(); /// - /// Lookup of the manifest resource names for a given target namespace, in the same order they - /// appear in . Lookups against this map replace per-namespace linear scans of - /// in the per-namespace emission path. + /// Enumerates the embedded-resource manifest names registered for the given target namespace, + /// in the order they should be appended to the projection of that namespace. Returns an empty + /// sequence when no additions are registered for . /// - public static readonly FrozenDictionary ByNamespace = - All.GroupBy(static x => x.Namespace) - .ToFrozenDictionary(static g => g.Key, static g => g.Select(x => x.ResourceName).ToArray()); + /// The target namespace. + /// The manifest resource names; an empty sequence if none. + public static IEnumerable EnumerateByNamespace(string ns) + { + return ByNamespace.TryGetValue(ns, out string[]? resourceNames) ? resourceNames : []; + } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj b/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj index 59963b3a7..248e98bf4 100644 --- a/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj +++ b/src/WinRT.Projection.Writer/WinRT.Projection.Writer.csproj @@ -64,7 +64,7 @@ SR.cs files would be misinterpreted by the SDK's CreateManifestResourceNames task as having Culture="SR" (treating '.SR.' as a locale identifier and embedding them as satellite resources), so we keep them on disk as '_SR.cs' and override the LogicalName to the - expected manifest path that Additions.All looks up at runtime. + expected manifest path that Additions looks up at runtime. --> Date: Tue, 19 May 2026 16:53:26 -0700 Subject: [PATCH 111/171] Reorder usings and add Callback using Clean up and reorder using directives across two files. Add WindowsRuntime.ProjectionWriter.Factories.Callbacks to AbiTypeWriter so callback factories are available, and move/remove duplicate WindowsRuntime.ProjectionWriter.References using directives in both AbiTypeWriter.cs and AbiMethodBodyFactory.RcwCaller.cs for consistency. --- .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 3 +-- src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs | 5 ++--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 8a2f8c84a..4c3f151fc 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -12,11 +12,10 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.References; using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; -using WindowsRuntime.ProjectionWriter.References; - namespace WindowsRuntime.ProjectionWriter.Factories; internal static partial class AbiMethodBodyFactory diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index e24a1a9f4..25bdeec2f 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -3,16 +3,15 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; -using WindowsRuntime.ProjectionWriter.Factories.Callbacks; +using WindowsRuntime.ProjectionWriter.References; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; using static WindowsRuntime.ProjectionWriter.References.WellKnownTypeNames; -using WindowsRuntime.ProjectionWriter.References; - namespace WindowsRuntime.ProjectionWriter.Helpers; /// From 866ee3321f4ea98039827fe2ccdc08dcb76e01c5 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 16:56:13 -0700 Subject: [PATCH 112/171] Use full type names for filter checks Replace usages of TypeFilter.Includes(type) with Includes(type.FullName) across the projection writer to consistently use fully-qualified type names for filtering. Remove the TypeDefinition overload and GetFullName helper from TypeFilter, and drop now-unused using directives. Updated files include AbiInterfaceFactory, multiple ProjectionGenerator partials (Component, GeneratedIids, Namespace), IidExpressionGenerator, TypedefNameWriter, and TypeFilter. This centralizes filtering on string full names and removes the redundant helper APIs. --- .../Factories/AbiInterfaceFactory.cs | 2 +- .../ProjectionGenerator.Component.cs | 2 +- .../ProjectionGenerator.GeneratedIids.cs | 4 +-- .../ProjectionGenerator.Namespace.cs | 8 ++--- .../Helpers/IidExpressionGenerator.cs | 3 +- .../Helpers/TypeFilter.cs | 33 ------------------- .../Helpers/TypedefNameWriter.cs | 2 +- 7 files changed, 11 insertions(+), 43 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 6cfa917b1..e57a39fac 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -495,7 +495,7 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj { TypeDefinition? owningClass = AbiTypeHelpers.GetExclusiveToType(context.Cache, type); - if (owningClass is not null && !context.Settings.Filter.Includes(owningClass)) + if (owningClass is not null && !context.Settings.Filter.Includes(owningClass.FullName)) { return; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs index 98a55ed29..68b1260e1 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Component.cs @@ -40,7 +40,7 @@ internal sealed partial class ProjectionGenerator { foreach (TypeDefinition type in members.Classes) { - if (!_settings.Filter.Includes(type)) + if (!_settings.Filter.Includes(type.FullName)) { continue; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs index 2b5b0e10e..930f017d0 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs @@ -37,7 +37,7 @@ internal void WriteGeneratedInterfaceIidsFile() { foreach (TypeDefinition type in nsMembers.Classes) { - if (!_settings.Filter.Includes(type)) + if (!_settings.Filter.Includes(type.FullName)) { continue; } @@ -76,7 +76,7 @@ internal void WriteGeneratedInterfaceIidsFile() { bool isFactoryInterface = factoryInterfacesGlobal.Contains(type); - if (!_settings.Filter.Includes(type) && !isFactoryInterface) + if (!_settings.Filter.Includes(type.FullName) && !isFactoryInterface) { continue; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index e89f852a6..28d207ac1 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -41,7 +41,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe writer.WriteLine("#pragma warning disable IL2026"); foreach (TypeDefinition type in members.Types) { - if (!_settings.Filter.Includes(type)) + if (!_settings.Filter.Includes(type.FullName)) { continue; } @@ -109,7 +109,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe foreach (TypeDefinition type in members.Types) { - if (!_settings.Filter.Includes(type)) + if (!_settings.Filter.Includes(type.FullName)) { continue; } @@ -168,7 +168,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe HashSet factoryInterfacesAllNs = []; foreach (TypeDefinition type in members.Types) { - if (!_settings.Filter.Includes(type)) + if (!_settings.Filter.Includes(type.FullName)) { continue; } @@ -196,7 +196,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe { bool isFactoryInterface = factoryInterfacesInThisNs.Contains(type); - if (!_settings.Filter.Includes(type) && !isFactoryInterface) + if (!_settings.Filter.Includes(type.FullName) && !isFactoryInterface) { continue; } diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index 2792027e6..e03b2f009 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -316,9 +316,10 @@ public static void WriteIidGuidPropertyForClassInterfaces(IndentedTextWriter wri } // Only emit if the interface is not in the projection (otherwise it'll be emitted naturally) - if (!context.Settings.Filter.Includes(ifaceType)) + if (!context.Settings.Filter.Includes(ifaceType.FullName)) { WriteIidGuidPropertyFromType(writer, context, ifaceType); + _ = interfacesEmitted.Add(ifaceType); } } diff --git a/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs b/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs index 1c2d64215..747820658 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs @@ -4,8 +4,6 @@ using System; using System.Collections.Generic; using System.Linq; -using AsmResolver; -using AsmResolver.DotNet; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -142,35 +140,4 @@ private static bool Match(string typeNamespace, string typeName, string rule) string rest = rule[(typeNamespace.Length + 1)..]; return typeName.StartsWith(rest, StringComparison.Ordinal); } - - /// - /// Returns whether the given passes the include/exclude filter. - /// Computes the type's full name (namespace.typeName) and delegates to - /// . - /// - /// The type definition to test. - /// if the type's full name is included. - public bool Includes(TypeDefinition type) - { - return Includes(GetFullName(type)); - } - - /// - /// Returns the full name of in the namespace.typeName form - /// (or just the type name when the namespace is empty). - /// - /// The type definition to format. - /// The fully-qualified type name. - public static string GetFullName(TypeDefinition type) - { - Utf8String? ns = type.Namespace; - Utf8String? name = type.Name; - - if (ns is null || ns.Length == 0) - { - return name?.Value ?? string.Empty; - } - - return ns + "." + (name?.Value ?? string.Empty); - } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index aca3c1e3c..f2637ec1e 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -38,7 +38,7 @@ public static void WriteFundamentalType(IndentedTextWriter writer, FundamentalTy /// When , always prepend the global::-qualified namespace prefix. public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypedefNameType nameType = TypedefNameType.Projected, bool forceWriteNamespace = false) { - bool authoredType = context.Settings.Component && context.Settings.Filter.Includes(type); + bool authoredType = context.Settings.Component && context.Settings.Filter.Includes(type.FullName); (string typeNamespace, string typeName) = type.Names(); if (nameType == TypedefNameType.NonProjected) From 04378a942cb53918d9287134777f1f4c9e8c8b35 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 17:03:16 -0700 Subject: [PATCH 113/171] Refactor EmitAbiMethodBodyIfSimple to use writer-managed indentation Replaces the manual string indent = " " / " " / callIndent + new string(' ', fixedNesting * 4) indent computation pattern with the IndentedTextWriter's IncreaseIndent/DecreaseIndent stack. The writer's indent prepending now provides all structural indent; raw multiline strings carry no literal indent prefix. Method body, try/finally, and fixed-block scopes all manage their nesting via writer.IncreaseIndent() / writer.DecreaseIndent() pairs. The indent, callIndent, and ixedNesting local variables are removed. The output changes are pure whitespace: - Continuation lines for multi-line method calls (e.g. ,\n arg patterns at parameter-list emit points) move from a shallow 6-sp indent to the writer's deeper natural indent. - The pre-existing alignment bug where `__retval_data` and `__X_data` emitted at 4 sp while `__retval_length` and `__X_length` sat at 12 sp is also fixed: `_data` lines now align with `_length` lines. No semantic changes; classified diffs are 100% indent-only across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../AbiMethodBodyFactory.RcwCaller.cs | 283 +++++++++--------- 1 file changed, 135 insertions(+), 148 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 4c3f151fc..9dab6ddb3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -197,11 +197,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec _ = fp.Append(", int"); writer.WriteLine(); - writer.WriteLine(isMultiline: true, """ - { - using WindowsRuntimeObjectReferenceValue thisValue = thisReference.AsValue(); - void* ThisPtr = thisValue.GetThisPtrUnsafe(); - """); + writer.IncreaseIndent(); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine("using WindowsRuntimeObjectReferenceValue thisValue = thisReference.AsValue();"); + writer.WriteLine("void* ThisPtr = thisValue.GetThisPtrUnsafe();"); // Declare 'using' marshaller values for ref-type parameters (these need disposing). for (int i = 0; i < sig.Parameters.Count; i++) @@ -213,7 +213,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); EmitMarshallerConvertToUnmanagedCallback cvt = EmitMarshallerConvertToUnmanaged(context, p.Type, callName); - writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{localName} = {cvt};"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{localName} = {cvt};"); } else if (p.Type.IsNullableT()) { @@ -221,7 +221,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); - writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{localName} = {innerMarshaller}.BoxToUnmanaged({callName});"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{localName} = {innerMarshaller}.BoxToUnmanaged({callName});"); } else if (p.Type.IsGenericInstance()) { @@ -231,9 +231,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - using WindowsRuntimeObjectReferenceValue __{{localName}} = ConvertToUnmanaged_{{localName}}(null, {{callName}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] + static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); + using WindowsRuntimeObjectReferenceValue __{{localName}} = ConvertToUnmanaged_{{localName}}(null, {{callName}}); """); } } @@ -257,7 +257,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); - writer.WriteLine($" global::ABI.System.Exception __{localName} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({callName});"); + writer.WriteLine($"global::ABI.System.Exception __{localName} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({callName});"); } // Declare locals for mapped value-type input parameters (DateTime/TimeSpan): convert via marshaller up-front. @@ -277,7 +277,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); - writer.WriteLine($" {AbiTypeHelpers.GetMappedAbiTypeName(p.Type)} __{localName} = {AbiTypeHelpers.GetMappedMarshallerName(p.Type)}.ConvertToUnmanaged({callName});"); + writer.WriteLine($"{AbiTypeHelpers.GetMappedAbiTypeName(p.Type)} __{localName} = {AbiTypeHelpers.GetMappedMarshallerName(p.Type)}.ConvertToUnmanaged({callName});"); } // Declare locals for complex-struct input parameters (e.g. ProfileUsage with nested @@ -302,7 +302,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } string localName = p.GetParamLocalName(paramNameOverride); - writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(context, pType)} __{localName} = default;"); + writer.WriteLine($"{AbiTypeHelpers.GetAbiStructTypeName(context, pType)} __{localName} = default;"); } // Declare locals for Out parameters (need to be passed as &__ to the call). @@ -312,8 +312,6 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); - writer.Write(" "); - string abi = AbiTypeHelpers.GetAbiLocalTypeName(context, uOut); writer.WriteLine($"{abi} __{localName} = default;"); } @@ -325,10 +323,8 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; - writer.WriteLine(isMultiline: true, $$""" - uint __{{localName}}_length = default; - - """); + writer.WriteLine($"uint __{localName}_length = default;"); + writer.WriteLine(); // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. string elemAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, sza.BaseType); @@ -368,11 +364,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string storageT = AbiTypeHelpers.GetArrayElementStorageType(context, szArr.BaseType); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16<{{storageT}}> {{names.InlineArray}}); - {{storageT}}[] {{names.ArrayFromPool}} = null; - Span<{{storageT}}> {{names.Span}} = {{callName}}.Length <= 16 - ? {{names.InlineArray}}[..{{callName}}.Length] - : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool<{{storageT}}>.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16<{{storageT}}> {{names.InlineArray}}); + {{storageT}}[] {{names.ArrayFromPool}} = null; + Span<{{storageT}}> {{names.Span}} = {{callName}}.Length <= 16 + ? {{names.InlineArray}}[..{{callName}}.Length] + : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool<{{storageT}}>.Shared.Rent({{callName}}.Length)); """); if (szArr.BaseType.IsString() && cat == ParameterCategory.PassArray) @@ -382,17 +378,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // fills HSTRING handles directly into the nint storage. writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16 {{names.InlineHeaderArray}}); - HStringHeader[] {{names.HeaderArrayFromPool}} = null; - Span {{names.HeaderSpan}} = {{callName}}.Length <= 16 - ? {{names.InlineHeaderArray}}[..{{callName}}.Length] - : ({{names.HeaderArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlineHeaderArray}}); + HStringHeader[] {{names.HeaderArrayFromPool}} = null; + Span {{names.HeaderSpan}} = {{callName}}.Length <= 16 + ? {{names.InlineHeaderArray}}[..{{callName}}.Length] + : ({{names.HeaderArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - Unsafe.SkipInit(out InlineArray16 {{names.InlinePinnedHandleArray}}); - nint[] {{names.PinnedHandleArrayFromPool}} = null; - Span {{names.PinnedHandleSpan}} = {{callName}}.Length <= 16 - ? {{names.InlinePinnedHandleArray}}[..{{callName}}.Length] - : ({{names.PinnedHandleArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + Unsafe.SkipInit(out InlineArray16 {{names.InlinePinnedHandleArray}}); + nint[] {{names.PinnedHandleArrayFromPool}} = null; + Span {{names.PinnedHandleSpan}} = {{callName}}.Length <= 16 + ? {{names.InlinePinnedHandleArray}}[..{{callName}}.Length] + : ({{names.PinnedHandleArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); """); } } @@ -400,42 +396,40 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (returnIsReceiveArray) { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt!; - writer.WriteLine(isMultiline: true, """ - uint __retval_length = default; - - """); + writer.WriteLine("uint __retval_length = default;"); + writer.WriteLine(); string retElemAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, retSz.BaseType); writer.WriteLine($"{retElemAbi}* __retval_data = default;"); } else if (returnIsHResultException) { - writer.WriteLine(" global::ABI.System.Exception __retval = default;"); + writer.WriteLine("global::ABI.System.Exception __retval = default;"); } else if (returnIsString || returnIsRefType) { - writer.WriteLine(" void* __retval = default;"); + writer.WriteLine("void* __retval = default;"); } else if (returnIsBlittableStruct) { - writer.WriteLine($" {AbiTypeHelpers.GetBlittableStructAbiType(context, rt!)} __retval = default;"); + writer.WriteLine($"{AbiTypeHelpers.GetBlittableStructAbiType(context, rt!)} __retval = default;"); } else if (returnIsComplexStruct) { - writer.WriteLine($" {AbiTypeHelpers.GetAbiStructTypeName(context, rt!)} __retval = default;"); + writer.WriteLine($"{AbiTypeHelpers.GetAbiStructTypeName(context, rt!)} __retval = default;"); } else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) { // Mapped value type return (e.g. DateTime/TimeSpan): use the ABI struct as __retval. - writer.WriteLine($" {AbiTypeHelpers.GetMappedAbiTypeName(rt)} __retval = default;"); + writer.WriteLine($"{AbiTypeHelpers.GetMappedAbiTypeName(rt)} __retval = default;"); } else if (rt is not null && rt.IsSystemType()) { // System.Type return: use ABI Type struct as __retval. - writer.WriteLine(" global::ABI.System.Type __retval = default;"); + writer.WriteLine("global::ABI.System.Type __retval = default;"); } else if (rt is not null) { - writer.WriteLine($" {AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, rt)} __retval = default;"); + writer.WriteLine($"{AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, rt)} __retval = default;"); } // Determine if we need a try/finally (for cleanup of string/refType return or receive array @@ -445,14 +439,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (needsTryFinally) { - writer.WriteLine(isMultiline: true, """ - try - { - """); + writer.WriteLine("try"); + writer.WriteLine("{"); + writer.IncreaseIndent(); } - string indent = needsTryFinally ? " " : " "; - // Inside try (if applicable): assign complex-struct input locals via marshaller. //.: '__value = ProfileUsageMarshaller.ConvertToUnmanaged(value);' // Includes both 'in' (ParameterCategory.In) and 'in T' (ParameterCategory.Ref) forms. @@ -475,7 +466,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); - writer.WriteLine($"{indent}__{localName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, pType)}.ConvertToUnmanaged({callName});"); + writer.WriteLine($"__{localName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, pType)}.ConvertToUnmanaged({callName});"); } // Type input params: set up TypeReference locals before the fixed block: @@ -496,7 +487,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); - writer.WriteLine($"{indent}global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({callName}, out TypeReference __{localName});"); + writer.WriteLine($"global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({callName}, out TypeReference __{localName});"); } // Open a SINGLE fixed-block for ALL pinnable inputs: @@ -555,7 +546,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRef = uRefSkip; string abiType = context.AbiTypeShapeResolver.IsBlittableStruct(uRef) ? AbiTypeHelpers.GetBlittableStructAbiType(context, uRef) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uRef); - writer.WriteLine($"{indent}{new string(' ', fixedNesting * 4)}fixed({abiType}* _{localName} = &{callName})"); + writer.WriteLine($"fixed({abiType}* _{localName} = &{callName})"); typedFixedCount++; } } @@ -567,7 +558,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (hasAnyVoidStarPinnable) { - writer.Write($"{indent}{new string(' ', fixedNesting * 4)}fixed(void* "); + writer.Write("fixed(void* "); bool first = true; for (int i = 0; i < sig.Parameters.Count; i++) { @@ -623,11 +614,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.Write(callName); } } - writer.WriteLine(isMultiline: true, $$""" - ) - {{indent}}{{new string(' ', fixedNesting * 4)}}{ - """); + writer.WriteLine(")"); + writer.WriteLine("{"); fixedNesting++; + writer.IncreaseIndent(); // Inside the body: emit HStringMarshaller calls for input string params. for (int i = 0; i < sig.Parameters.Count; i++) { @@ -638,7 +628,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = sig.Parameters[i].GetParamName(paramNameOverride); string localName = sig.Parameters[i].GetParamLocalName(paramNameOverride); - writer.WriteLine($"{indent}{new string(' ', fixedNesting * 4)}HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{localName}, {callName}?.Length, out HStringReference __{localName});"); + writer.WriteLine($"HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{localName}, {callName}?.Length, out HStringReference __{localName});"); } stringPinnablesEmitted = true; } @@ -646,15 +636,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { // Typed fixed lines exist but no void* combined block - we need a body block // to host them. Open a brace block after the last typed fixed line. - writer.WriteLine($"{indent}{new string(' ', fixedNesting * 4)}{{"); + writer.WriteLine("{"); fixedNesting++; + writer.IncreaseIndent(); } // Suppress unused variable warning when block above doesn't fire. _ = stringPinnablesEmitted; - string callIndent = indent + new string(' ', fixedNesting * 4); - // For non-blittable PassArray params, emit CopyToUnmanaged_ (UnsafeAccessor) and call // it to populate the inline/pooled storage from the user-supplied span. For string arrays, // use HStringArrayMarshaller.ConvertToUnmanagedUnsafe instead. @@ -694,11 +683,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}HStringArrayMarshaller.ConvertToUnmanagedUnsafe( - {{callIndent}} source: {{callName}}, - {{callIndent}} hstringHeaders: (HStringHeader*) _{{localName}}_inlineHeaderArray, - {{callIndent}} hstrings: {{names.Span}}, - {{callIndent}} pinnedGCHandles: {{names.PinnedHandleSpan}}); + HStringArrayMarshaller.ConvertToUnmanagedUnsafe( + source: {{callName}}, + hstringHeaders: (HStringHeader*) _{{localName}}_inlineHeaderArray, + hstrings: {{names.Span}}, + pinnedGCHandles: {{names.PinnedHandleSpan}}); """); } else @@ -744,14 +733,13 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - {{callIndent}}static extern void CopyToUnmanaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{dataParamType}} data); - {{callIndent}}CopyToUnmanaged_{{localName}}(null, {{callName}}, (uint){{callName}}.Length, {{dataCastType}}_{{localName}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] + static extern void CopyToUnmanaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{dataParamType}} data); + CopyToUnmanaged_{{localName}}(null, {{callName}}, (uint){{callName}}.Length, {{dataCastType}}_{{localName}}); """); } } - writer.Write(callIndent); // method/property is [NoException] (its HRESULT is contractually S_OK). if (!isNoExcept) { @@ -912,9 +900,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] - {{callIndent}}static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{elementAbi}}* data, Span<{{elementProjected}}> span); - {{callIndent}}CopyToManaged_{{localName}}(null, (uint){{names.Span}}.Length, ({{elementAbi}}*)_{{localName}}, {{callName}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] + static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{elementAbi}}* data, Span<{{elementProjected}}> span); + CopyToManaged_{{localName}}(null, (uint){{names.Span}}.Length, ({{elementAbi}}*)_{{localName}}, {{callName}}); """); } @@ -935,14 +923,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(uOut, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - {{callIndent}}static extern {{projectedTypeName}} ConvertToManaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - {{callIndent}}{{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] + static extern {{projectedTypeName}} ConvertToManaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); + {{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}); """); continue; } - writer.Write($"{callIndent}{callName} = "); + writer.Write($"{callName} = "); if (uOut.IsString()) { @@ -1004,9 +992,9 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - {{callIndent}}static extern {{elementProjected}}[] ConvertToManaged_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); - {{callIndent}}{{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] + static extern {{elementProjected}}[] ConvertToManaged_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); + {{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); """); } @@ -1018,18 +1006,18 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSz.BaseType)); string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType); writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - {{callIndent}}static extern {{elementProjected}}[] ConvertToManaged_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); - {{callIndent}}return ConvertToManaged_retval(null, __retval_length, __retval_data); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] + static extern {{elementProjected}}[] ConvertToManaged_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); + return ConvertToManaged_retval(null, __retval_length, __retval_data); """); } else if (returnIsHResultException) { - writer.WriteLine($"{callIndent}return global::ABI.System.ExceptionMarshaller.ConvertToManaged(__retval);"); + writer.WriteLine("return global::ABI.System.ExceptionMarshaller.ConvertToManaged(__retval);"); } else if (returnIsString) { - writer.WriteLine($"{callIndent}return HStringMarshaller.ConvertToManaged(__retval);"); + writer.WriteLine("return HStringMarshaller.ConvertToManaged(__retval);"); } else if (returnIsRefType) { @@ -1038,38 +1026,36 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Nullable return: use Marshaller.UnboxToManaged.; // there is no NullableMarshaller, the inner-T marshaller has UnboxToManaged. (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, rt); - writer.WriteLine($"{callIndent}return {innerMarshaller}.UnboxToManaged(__retval);"); + writer.WriteLine($"return {innerMarshaller}.UnboxToManaged(__retval);"); } else if (rt.IsGenericInstance()) { string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(rt, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt, false); writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - {{callIndent}}static extern {{projectedTypeName}} ConvertToManaged_retval([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - {{callIndent}}return ConvertToManaged_retval(null, __retval); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] + static extern {{projectedTypeName}} ConvertToManaged_retval([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); + return ConvertToManaged_retval(null, __retval); """); } else { EmitMarshallerConvertToManagedCallback cvt = EmitMarshallerConvertToManaged(context, rt, "__retval"); - writer.WriteLine($"{callIndent}return {cvt};"); + writer.WriteLine($"return {cvt};"); } } else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) { // Mapped value type return (e.g. DateTime/TimeSpan): convert ABI struct back via marshaller. - writer.WriteLine($"{callIndent}return {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToManaged(__retval);"); + writer.WriteLine($"return {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToManaged(__retval);"); } else if (rt is not null && rt.IsSystemType()) { // System.Type return: convert ABI Type struct back to System.Type via TypeMarshaller. - writer.WriteLine($"{callIndent}return global::ABI.System.TypeMarshaller.ConvertToManaged(__retval);"); + writer.WriteLine("return global::ABI.System.TypeMarshaller.ConvertToManaged(__retval);"); } else if (returnIsBlittableStruct) { - writer.Write(callIndent); - if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) { // Mapped value type return: convert ABI struct back to projected via marshaller. @@ -1082,11 +1068,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (returnIsComplexStruct) { - writer.WriteLine($"{callIndent}return {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.ConvertToManaged(__retval);"); + writer.WriteLine($"return {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.ConvertToManaged(__retval);"); } else { - writer.Write($"{callIndent}return "); + writer.Write("return "); string projected = MethodFactory.WriteProjectedSignature(context, rt!, false).Format(); string abiType = AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, rt!); @@ -1104,16 +1090,16 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Close fixed blocks (innermost first). for (int i = fixedNesting - 1; i >= 0; i--) { - writer.WriteLine($"{indent}{new string(' ', i * 4)}}}"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } if (needsTryFinally) { - writer.WriteLine(isMultiline: true, """ - } - finally - { - """); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.WriteLine("finally"); + using IndentedTextWriter.Block __finallyBlock = writer.WriteBlock(); // Order matches truth: // 0. Complex-struct input param Dispose (e.g. ProfileUsageMarshaller.Dispose(__value)) @@ -1141,7 +1127,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } string localName = p.GetParamLocalName(paramNameOverride); - writer.WriteLine($" {AbiTypeHelpers.GetMarshallerFullName(writer, context, pType)}.Dispose(__{localName});"); + writer.WriteLine($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, pType)}.Dispose(__{localName});"); } // 1. Cleanup non-blittable PassArray/FillArray params: @@ -1182,10 +1168,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localNameH = p.GetParamLocalName(paramNameOverride); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - if (__{{localNameH}}_arrayFromPool is not null) - { - global::System.Buffers.ArrayPool.Shared.Return(__{{localNameH}}_arrayFromPool); - } + if (__{{localNameH}}_arrayFromPool is not null) + { + global::System.Buffers.ArrayPool.Shared.Return(__{{localNameH}}_arrayFromPool); + } """); continue; } @@ -1201,27 +1187,27 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.PassArray) { writer.WriteLine(isMultiline: true, $$""" - HStringArrayMarshaller.Dispose({{names.PinnedHandleSpan}}); + HStringArrayMarshaller.Dispose({{names.PinnedHandleSpan}}); - if ({{names.PinnedHandleArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool.Shared.Return({{names.PinnedHandleArrayFromPool}}); - } + if ({{names.PinnedHandleArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool.Shared.Return({{names.PinnedHandleArrayFromPool}}); + } - if ({{names.HeaderArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool.Shared.Return({{names.HeaderArrayFromPool}}); - } + if ({{names.HeaderArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool.Shared.Return({{names.HeaderArrayFromPool}}); + } """); } // Both PassArray and FillArray need the inline-array's nint pool returned. writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - if ({{names.ArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool.Shared.Return({{names.ArrayFromPool}}); - } + if ({{names.ArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool.Shared.Return({{names.ArrayFromPool}}); + } """); } else @@ -1248,18 +1234,18 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec disposeCastType = "(void**)"; } writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] - static extern void Dispose_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{disposeDataParamType}} + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] + static extern void Dispose_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{disposeDataParamType}} """); writer.WriteIf(!disposeDataParamType.EndsWith("data", StringComparison.Ordinal), " data"); writer.WriteLine(isMultiline: true, $$""" ); - fixed({{fixedPtrType}} _{{localName}} = {{names.Span}}) - { - Dispose_{{localName}}(null, (uint) {{names.Span}}.Length, {{disposeCastType}}_{{localName}}); - } + fixed({{fixedPtrType}} _{{localName}} = {{names.Span}}) + { + Dispose_{{localName}}(null, (uint) {{names.Span}}.Length, {{disposeCastType}}_{{localName}}); + } """); } @@ -1269,10 +1255,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string poolStorageT = AbiTypeHelpers.GetArrayElementStorageType(context, szArr.BaseType); writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - if ({{names.ArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool<{{poolStorageT}}>.Shared.Return({{names.ArrayFromPool}}); - } + if ({{names.ArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool<{{poolStorageT}}>.Shared.Return({{names.ArrayFromPool}}); + } """); } @@ -1286,19 +1272,19 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (uOut.IsString()) { - writer.WriteLine($" HStringMarshaller.Free(__{localName});"); + writer.WriteLine($"HStringMarshaller.Free(__{localName});"); } else if (uOut.IsObject() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uOut) || uOut.IsGenericInstance()) { - writer.WriteLine($" WindowsRuntimeUnknownMarshaller.Free(__{localName});"); + writer.WriteLine($"WindowsRuntimeUnknownMarshaller.Free(__{localName});"); } else if (uOut.IsSystemType()) { - writer.WriteLine($" global::ABI.System.TypeMarshaller.Dispose(__{localName});"); + writer.WriteLine($"global::ABI.System.TypeMarshaller.Dispose(__{localName});"); } else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) { - writer.WriteLine($" {AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.Dispose(__{localName});"); + writer.WriteLine($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.Dispose(__{localName});"); } } @@ -1313,46 +1299,47 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] - static extern void Free_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] + static extern void Free_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); - Free_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); + Free_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); """); } // 4. Free return value (__retval) — emitted last to match truth ordering. if (returnIsString) { - writer.WriteLine(" HStringMarshaller.Free(__retval);"); + writer.WriteLine("HStringMarshaller.Free(__retval);"); } else if (returnIsRefType) { - writer.WriteLine(" WindowsRuntimeUnknownMarshaller.Free(__retval);"); + writer.WriteLine("WindowsRuntimeUnknownMarshaller.Free(__retval);"); } else if (returnIsComplexStruct) { - writer.WriteLine($" {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.Dispose(__retval);"); + writer.WriteLine($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.Dispose(__retval);"); } else if (facts.ReturnIsSystemTypeForCleanup) { // System.Type return: dispose the ABI.System.Type's HSTRING fields. - writer.WriteLine(" global::ABI.System.TypeMarshaller.Dispose(__retval);"); + writer.WriteLine("global::ABI.System.TypeMarshaller.Dispose(__retval);"); } else if (returnIsReceiveArray) { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt!; string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] - static extern void Free_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); - Free_retval(null, __retval_length, __retval_data); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] + static extern void Free_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); + Free_retval(null, __retval_length, __retval_data); """); } - writer.WriteLine(" }"); } - writer.WriteLine(" }"); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.DecreaseIndent(); } /// From abc36d7d9bce96ca117a069f88613aa15410868e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 17:29:52 -0700 Subject: [PATCH 114/171] Refactor EmitDoAbiBodyIfSimple to use writer-managed indentation Replaces the 18 `writer.Write[Line]($" ...")` literal 4-space prefixes used to indent code inside the `try` block, with proper `IncreaseIndent()` / `DecreaseIndent()` calls. The `try`/`catch`/`finally` opener/closer multiline raw strings are split into individual `WriteLine` calls. Multiline raw strings emitting `[UnsafeAccessor]` hoists inside the `try` block (the `CopyToManaged_`, `ConvertToManaged_arg_`, and `CopyToUnmanaged_` declarations) have their dedent indent rebased 4 sp deeper to compensate for the writer being one level deeper inside the new `try` scope. The finally body's per-array cleanup block (`if (...) { ArrayPool... }`) previously had a weird-Allman misalignment in its raw string (`{` at +4 sp relative to `if`). The split into separate `WriteLine` calls with `IncreaseIndent` produces proper Allman alignment. The output changes are pure whitespace: - The finally body's `{` and `}` braces move from +4 sp to align with the surrounding `if` keyword (strict bug fix). No semantic changes; classified diffs are 100% indent-only across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 110 +++++++++--------- 1 file changed, 53 insertions(+), 57 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 8ad72f2b8..79d54dfe9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -246,10 +246,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection """); } } - writer.WriteLine(isMultiline: true, """ - try - { - """); + writer.WriteLine("try"); + writer.WriteLine("{"); + writer.IncreaseIndent(); // For non-blittable PassArray params (read-only input arrays), emit CopyToManaged_ // via UnsafeAccessor to convert the native ABI buffer into the managed Span the @@ -292,10 +291,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] - static extern void CopyToManaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); - CopyToManaged_{{raw}}(null, __{{raw}}Size, {{dataCastExpr}}, __{{raw}}); - """); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] + static extern void CopyToManaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); + CopyToManaged_{{raw}}(null, __{{raw}}Size, {{dataCastExpr}}, __{{raw}}); + """); } // For generic instance ABI input parameters, emit local UnsafeAccessor delegates and locals @@ -310,7 +309,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string rawName = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(rawName); (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); - writer.WriteLine($" var __arg_{rawName} = {innerMarshaller}.UnboxToManaged({callName});"); + writer.WriteLine($"var __arg_{rawName} = {innerMarshaller}.UnboxToManaged({callName});"); } else if (p.Type.IsGenericInstance()) { @@ -319,33 +318,29 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{projectedTypeName}} ConvertToManaged_arg_{{rawName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - var __arg_{{rawName}} = ConvertToManaged_arg_{{rawName}}(null, {{callName}}); - """); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] + static extern {{projectedTypeName}} ConvertToManaged_arg_{{rawName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); + var __arg_{{rawName}} = ConvertToManaged_arg_{{rawName}}(null, {{callName}}); + """); } } if (returnIsString) { - writer.Write($" {retLocalName} = "); + writer.Write($"{retLocalName} = "); } else if (returnIsRefType) { - writer.Write($" {retLocalName} = "); + writer.Write($"{retLocalName} = "); } else if (returnIsReceiveArrayDoAbi) { // For T[] return: assign to existing local. - writer.Write($" {retLocalName} = "); + writer.Write($"{retLocalName} = "); } else if (rt is not null) { - writer.Write($" {retLocalName} = "); - } - else - { - writer.Write(" "); + writer.Write($"{retLocalName} = "); } if (isGetter) @@ -493,7 +488,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Enums, bool, char, and primitives: the local __ is already the ABI form. rhs = $"__{raw}"; } - writer.WriteLine($" *{ptr} = {rhs};"); + writer.WriteLine($"*{ptr} = {rhs};"); } // After call: for ReceiveArray params, emit ConvertToUnmanaged_ call (the @@ -504,7 +499,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); - writer.WriteLine($" ConvertToUnmanaged_{raw}(null, __{raw}, out *__{raw}Size, out *{ptr});"); + writer.WriteLine($"ConvertToUnmanaged_{raw}(null, __{raw}, out *__{raw}Size, out *{ptr});"); } // After call: for non-blittable FillArray params (Span where T is string/runtime @@ -536,21 +531,21 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{elementAbi}}* data); - CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, ({{elementAbi}}*){{ptr}}); - """); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] + static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{elementAbi}}* data); + CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, ({{elementAbi}}*){{ptr}}); + """); } if (rt is not null) { if (returnIsHResultExceptionDoAbi) { - writer.WriteLine($" *{retParamName} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({retLocalName});"); + writer.WriteLine($"*{retParamName} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({retLocalName});"); } else if (returnIsString) { - writer.WriteLine($" *{retParamName} = HStringMarshaller.ConvertToUnmanaged({retLocalName});"); + writer.WriteLine($"*{retParamName} = HStringMarshaller.ConvertToUnmanaged({retLocalName});"); } else if (returnIsRefType) { @@ -558,59 +553,60 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { // Nullable return (server-side): use Marshaller.BoxToUnmanaged. (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, rt); - writer.WriteLine($" *{retParamName} = {innerMarshaller}.BoxToUnmanaged({retLocalName}).DetachThisPtrUnsafe();"); + writer.WriteLine($"*{retParamName} = {innerMarshaller}.BoxToUnmanaged({retLocalName}).DetachThisPtrUnsafe();"); } else if (returnIsGenericInstance) { // Generic instance return: use the UnsafeAccessor static local function declared at // the top of the method body via the M12 hoisting pass; just emit the call here. - writer.WriteLine($" *{retParamName} = ConvertToUnmanaged_{retParamName}(null, {retLocalName}).DetachThisPtrUnsafe();"); + writer.WriteLine($"*{retParamName} = ConvertToUnmanaged_{retParamName}(null, {retLocalName}).DetachThisPtrUnsafe();"); } else { EmitMarshallerConvertToUnmanagedCallback cvt = EmitMarshallerConvertToUnmanaged(context, rt!, retLocalName); - writer.WriteLine($" *{retParamName} = {cvt}.DetachThisPtrUnsafe();"); + writer.WriteLine($"*{retParamName} = {cvt}.DetachThisPtrUnsafe();"); } } else if (returnIsReceiveArrayDoAbi) { // Return-receive-array: emit ConvertToUnmanaged_ call (declaration // was hoisted to the top of the method body). - writer.WriteLine($" ConvertToUnmanaged_{retParamName}(null, {retLocalName}, out *{retSizeParamName}, out *{retParamName});"); + writer.WriteLine($"ConvertToUnmanaged_{retParamName}(null, {retLocalName}, out *{retSizeParamName}, out *{retParamName});"); } else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) { // Mapped value type return (DateTime/TimeSpan): convert via marshaller. - writer.WriteLine($" *{retParamName} = {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToUnmanaged({retLocalName});"); + writer.WriteLine($"*{retParamName} = {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToUnmanaged({retLocalName});"); } else if (rt.IsSystemType()) { // System.Type return (server-side): convert managed System.Type to ABI Type struct. - writer.WriteLine($" *{retParamName} = global::ABI.System.TypeMarshaller.ConvertToUnmanaged({retLocalName});"); + writer.WriteLine($"*{retParamName} = global::ABI.System.TypeMarshaller.ConvertToUnmanaged({retLocalName});"); } else if (context.AbiTypeShapeResolver.IsComplexStruct(rt)) { // Complex struct return (server-side): convert managed struct to ABI struct via marshaller. - writer.WriteLine($" *{retParamName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt)}.ConvertToUnmanaged({retLocalName});"); + writer.WriteLine($"*{retParamName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt)}.ConvertToUnmanaged({retLocalName});"); } else if (returnIsBlittableStruct) { - writer.WriteLine($" *{retParamName} = {retLocalName};"); + writer.WriteLine($"*{retParamName} = {retLocalName};"); } else { - writer.WriteLine($" *{retParamName} = {retLocalName};"); + writer.WriteLine($"*{retParamName} = {retLocalName};"); } } - writer.WriteLine(isMultiline: true, """ - return 0; - } - catch (Exception __exception__) - { - return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__); - } - """); + writer.WriteLine("return 0;"); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.WriteLine("catch (Exception __exception__)"); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine("return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__);"); + writer.DecreaseIndent(); + writer.WriteLine("}"); // For non-blittable PassArray params, emit finally block with ArrayPool.Shared.Return. bool hasNonBlittableArrayDoAbi = false; @@ -640,10 +636,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (hasNonBlittableArrayDoAbi) { - writer.WriteLine(isMultiline: true, """ - finally - { - """); + writer.WriteLine("finally"); + writer.WriteLine("{"); + writer.IncreaseIndent(); for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; @@ -667,13 +662,14 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - if (__{{raw}}_arrayFromPool is not null) - { - global::System.Buffers.ArrayPool<{{elementProjected}}>.Shared.Return(__{{raw}}_arrayFromPool); - } - """); - } + writer.WriteLine($"if (__{raw}_arrayFromPool is not null)"); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine($"global::System.Buffers.ArrayPool<{elementProjected}>.Shared.Return(__{raw}_arrayFromPool);"); + writer.DecreaseIndent(); + writer.WriteLine("}"); + } + writer.DecreaseIndent(); writer.WriteLine("}"); } } From 4ecc8ae84199624585ba4e32871365e74f3d932d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 17:51:56 -0700 Subject: [PATCH 115/171] Refactor EmitFactoryCallbackClass to use writer-managed indentation Replaces the manual `string baseIndent = " "` / `" "` and `string callIndent = baseIndent + new string(' ', fixedNesting * 4)` and `string innerIndent = baseIndent + new string(' ', fixedNesting * 4)` and `string indent = baseIndent + new string(' ', i * 4)` indent computation patterns with proper `IncreaseIndent()` / `DecreaseIndent()` calls on the writer. The writer's indent stack now models the method body, try/finally, and fixed-block scopes: - Method body enters at level 4 (depth from class scope, after emitting the `Invoke(...) {` signature). - `try {` block bumps to level 5. - `fixed(...) {` block bumps another level. - All closes use `DecreaseIndent()` followed by `WriteLine("}")`. Multiline raw strings inside the body have their literal indent prefixes adjusted to match the writer's new depth (8 sp stripped from body content, 4 sp from try-content, etc.). The output changes are pure whitespace: - Continuation lines for multi-arg method calls (`,\n argX` patterns) move from a shallow ~10-sp indent to the writer's deeper natural indent (~22 or ~26 sp). No semantic changes; classified diffs are 100% indent-only across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ConstructorFactory.FactoryCallbacks.cs | 212 +++++++++--------- 1 file changed, 102 insertions(+), 110 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 0cf18895d..af2182cff 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -111,11 +111,12 @@ public override unsafe void Invoke( return; } - writer.WriteLine(isMultiline: true, $$""" - using WindowsRuntimeObjectReferenceValue activationFactoryValue = {{factoryObjRefName}}.AsValue(); - void* ThisPtr = activationFactoryValue.GetThisPtrUnsafe(); - ref readonly {{argsName}} args = ref additionalParameters.GetValueRefUnsafe<{{argsName}}>(); - """); + writer.IncreaseIndent(); + writer.IncreaseIndent(); + + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue activationFactoryValue = {factoryObjRefName}.AsValue();"); + writer.WriteLine("void* ThisPtr = activationFactoryValue.GetThisPtrUnsafe();"); + writer.WriteLine($"ref readonly {argsName} args = ref additionalParameters.GetValueRefUnsafe<{argsName}>();"); // Bind each arg from the args struct to a local of its ABI-marshalable input type. // Bind arg locals. @@ -125,7 +126,7 @@ public override unsafe void Invoke( string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - writer.Write(" "); + // For array params, the bind type is ReadOnlySpan / Span (not the SzArray). if (cat == ParameterCategory.PassArray) { @@ -161,17 +162,15 @@ public override unsafe void Invoke( if (p.Type.IsNullableT()) { (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); - writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{raw} = {innerMarshaller}.BoxToUnmanaged({pname});"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{raw} = {innerMarshaller}.BoxToUnmanaged({pname});"); continue; } string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - using WindowsRuntimeObjectReferenceValue __{{raw}} = ConvertToUnmanaged_{{raw}}(null, {{pname}}); - """); + writer.WriteLine("[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = \"ConvertToUnmanaged\")]"); + writer.WriteLine($"static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{raw}([UnsafeAccessorType(\"{interopTypeName}\")] object _, {projectedTypeName} value);"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{raw} = ConvertToUnmanaged_{raw}(null, {pname});"); } // For runtime class / object params, emit `using WindowsRuntimeObjectReferenceValue __ = ...ConvertToUnmanaged();` @@ -193,7 +192,7 @@ public override unsafe void Invoke( string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); EmitMarshallerConvertToUnmanagedCallback cvt = AbiMethodBodyFactory.EmitMarshallerConvertToUnmanaged(context, p.Type, pname); - writer.WriteLine($" using WindowsRuntimeObjectReferenceValue __{raw} = {cvt};"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{raw} = {cvt};"); } // For composable factories, marshal the additional `baseInterface` (which is a @@ -201,10 +200,8 @@ public override unsafe void Invoke( // using WindowsRuntimeObjectReferenceValue __baseInterface = WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(baseInterface); if (isComposable) { - writer.WriteLine(isMultiline: true, """ - using WindowsRuntimeObjectReferenceValue __baseInterface = WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(baseInterface); - void* __innerInterface = default; - """); + writer.WriteLine("using WindowsRuntimeObjectReferenceValue __baseInterface = WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(baseInterface);"); + writer.WriteLine("void* __innerInterface = default;"); } // For mapped value-type params (DateTime, TimeSpan), emit ABI local + marshaller conversion. @@ -221,7 +218,7 @@ public override unsafe void Invoke( string pname = IdentifierEscaping.EscapeIdentifier(raw); string abiType = AbiTypeHelpers.GetMappedAbiTypeName(p.Type); string marshaller = AbiTypeHelpers.GetMappedMarshallerName(p.Type); - writer.WriteLine($" {abiType} __{raw} = {marshaller}.ConvertToUnmanaged({pname});"); + writer.WriteLine($"{abiType} __{raw} = {marshaller}.ConvertToUnmanaged({pname});"); } // For HResultException params, emit ABI local + ExceptionMarshaller conversion. @@ -238,7 +235,7 @@ public override unsafe void Invoke( string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); - writer.WriteLine($" global::ABI.System.Exception __{raw} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({pname});"); + writer.WriteLine($"global::ABI.System.Exception __{raw} = global::ABI.System.ExceptionMarshaller.ConvertToUnmanaged({pname});"); } // Declare InlineArray16 + ArrayPool fallback for non-blittable PassArray params @@ -269,43 +266,37 @@ public override unsafe void Invoke( string callName = IdentifierEscaping.EscapeIdentifier(raw); ArrayTempNames names = new(raw); writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16 {{names.InlineArray}}); - nint[] {{names.ArrayFromPool}} = null; - Span {{names.Span}} = {{callName}}.Length <= 16 - ? {{names.InlineArray}}[..{{callName}}.Length] - : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - """); + writer.WriteLine($"Unsafe.SkipInit(out InlineArray16 {names.InlineArray});"); + writer.WriteLine($"nint[] {names.ArrayFromPool} = null;"); + writer.WriteLine($"Span {names.Span} = {callName}.Length <= 16"); + writer.WriteLine($" ? {names.InlineArray}[..{callName}.Length]"); + writer.WriteLine($" : ({names.ArrayFromPool} = global::System.Buffers.ArrayPool.Shared.Rent({callName}.Length));"); if (szArr.BaseType.IsString()) { writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16 {{names.InlineHeaderArray}}); - HStringHeader[] {{names.HeaderArrayFromPool}} = null; - Span {{names.HeaderSpan}} = {{callName}}.Length <= 16 - ? {{names.InlineHeaderArray}}[..{{callName}}.Length] - : ({{names.HeaderArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - - Unsafe.SkipInit(out InlineArray16 {{names.InlinePinnedHandleArray}}); - nint[] {{names.PinnedHandleArrayFromPool}} = null; - Span {{names.PinnedHandleSpan}} = {{callName}}.Length <= 16 - ? {{names.InlinePinnedHandleArray}}[..{{callName}}.Length] - : ({{names.PinnedHandleArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); - """); + writer.WriteLine($"Unsafe.SkipInit(out InlineArray16 {names.InlineHeaderArray});"); + writer.WriteLine($"HStringHeader[] {names.HeaderArrayFromPool} = null;"); + writer.WriteLine($"Span {names.HeaderSpan} = {callName}.Length <= 16"); + writer.WriteLine($" ? {names.InlineHeaderArray}[..{callName}.Length]"); + writer.WriteLine($" : ({names.HeaderArrayFromPool} = global::System.Buffers.ArrayPool.Shared.Rent({callName}.Length));"); + writer.WriteLine(); + writer.WriteLine($"Unsafe.SkipInit(out InlineArray16 {names.InlinePinnedHandleArray});"); + writer.WriteLine($"nint[] {names.PinnedHandleArrayFromPool} = null;"); + writer.WriteLine($"Span {names.PinnedHandleSpan} = {callName}.Length <= 16"); + writer.WriteLine($" ? {names.InlinePinnedHandleArray}[..{callName}.Length]"); + writer.WriteLine($" : ({names.PinnedHandleArrayFromPool} = global::System.Buffers.ArrayPool.Shared.Rent({callName}.Length));"); } } - writer.WriteLine(" void* __retval = default;"); + writer.WriteLine("void* __retval = default;"); if (hasNonBlittableArray) { - writer.WriteLine(isMultiline: true, """ - try - { - """); + writer.WriteLine("try"); + writer.WriteLine("{"); + writer.IncreaseIndent(); } - string baseIndent = hasNonBlittableArray ? " " : " "; // For System.Type params, pre-marshal to TypeReference (must be declared OUTSIDE the // fixed() block since the fixed block pins the resulting reference). @@ -320,7 +311,7 @@ public override unsafe void Invoke( string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); - writer.WriteLine($"{baseIndent}global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({pname}, out TypeReference __{raw});"); + writer.WriteLine($"global::ABI.System.TypeMarshaller.ConvertToUnmanagedUnsafe({pname}, out TypeReference __{raw});"); } // Open ONE combined "fixed(void* _a = ..., _b = ..., ...)" block for ALL pinnable @@ -345,8 +336,7 @@ public override unsafe void Invoke( if (pinnableCount > 0) { - string indent = baseIndent; - writer.Write($"{indent}fixed(void* "); + writer.Write("fixed(void* "); bool firstPin = true; for (int i = 0; i < paramCount; i++) { @@ -383,7 +373,10 @@ public override unsafe void Invoke( { writer.Write(pname); } - else { writer.Write($"__{raw}_span"); } + else + { + writer.Write($"__{raw}_span"); + } if (isStringElem) { @@ -396,14 +389,14 @@ public override unsafe void Invoke( writer.Write(pname); } } - writer.WriteLine(isMultiline: true, $$""" - ) - {{indent}}{ - """); + + writer.WriteLine(")"); + writer.WriteLine("{"); + writer.IncreaseIndent(); fixedNesting = 1; + // Inside the block: emit HStringMarshaller.ConvertToUnmanagedUnsafe for each // string input. The HStringReference local lives stack-only. - string innerIndent = baseIndent + new string(' ', fixedNesting * 4); for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; @@ -415,12 +408,10 @@ public override unsafe void Invoke( string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); - writer.WriteLine($"{innerIndent}HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{raw}, {pname}?.Length, out HStringReference __{raw});"); + writer.WriteLine($"HStringMarshaller.ConvertToUnmanagedUnsafe((char*)_{raw}, {pname}?.Length, out HStringReference __{raw});"); } } - string callIndent = baseIndent + new string(' ', fixedNesting * 4); - // Emit CopyToUnmanaged for non-blittable PassArray params. for (int i = 0; i < paramCount; i++) { @@ -448,26 +439,22 @@ public override unsafe void Invoke( if (szArr.BaseType.IsString()) { - writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}HStringArrayMarshaller.ConvertToUnmanagedUnsafe( - {{callIndent}} source: {{pname}}, - {{callIndent}} hstringHeaders: (HStringHeader*) _{{raw}}_inlineHeaderArray, - {{callIndent}} hstrings: {{names.Span}}, - {{callIndent}} pinnedGCHandles: {{names.PinnedHandleSpan}}); - """); + writer.WriteLine("HStringArrayMarshaller.ConvertToUnmanagedUnsafe("); + writer.WriteLine($" source: {pname},"); + writer.WriteLine($" hstringHeaders: (HStringHeader*) _{raw}_inlineHeaderArray,"); + writer.WriteLine($" hstrings: {names.Span},"); + writer.WriteLine($" pinnedGCHandles: {names.PinnedHandleSpan});"); } else { WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - writer.WriteLine(isMultiline: true, $$""" - {{callIndent}}[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - {{callIndent}}static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, void** data); - {{callIndent}}CopyToUnmanaged_{{raw}}(null, {{pname}}, (uint){{pname}}.Length, (void**)_{{raw}}); - """); + writer.WriteLine("[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = \"CopyToUnmanaged\")]"); + writer.WriteLine($"static extern void CopyToUnmanaged_{raw}([UnsafeAccessorType(\"{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}\")] object _, ReadOnlySpan<{elementProjected}> span, uint length, void** data);"); + writer.WriteLine($"CopyToUnmanaged_{raw}(null, {pname}, (uint){pname}.Length, (void**)_{raw});"); } } - writer.Write($"{callIndent}RestrictedErrorInfo.ThrowExceptionForHR((*(delegate* unmanaged[MemberFunction]= 0; i--) + for (int i = 0; i < fixedNesting; i++) { - string indent = baseIndent + new string(' ', i * 4); - writer.WriteLine($"{indent}}}"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } // Close try and emit finally with cleanup for non-blittable PassArray params. if (hasNonBlittableArray) { - writer.WriteLine(isMultiline: true, """ - } - finally - { - """); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.WriteLine("finally"); + writer.WriteLine("{"); + writer.IncreaseIndent(); for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; @@ -611,44 +598,49 @@ public override unsafe void Invoke( if (szArr.BaseType.IsString()) { writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - HStringArrayMarshaller.Dispose({{names.PinnedHandleSpan}}); - - if ({{names.PinnedHandleArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool.Shared.Return({{names.PinnedHandleArrayFromPool}}); - } - - if ({{names.HeaderArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool.Shared.Return({{names.HeaderArrayFromPool}}); - } - """); + writer.WriteLine($"HStringArrayMarshaller.Dispose({names.PinnedHandleSpan});"); + writer.WriteLine(); + writer.WriteLine($"if ({names.PinnedHandleArrayFromPool} is not null)"); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.PinnedHandleArrayFromPool});"); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine($"if ({names.HeaderArrayFromPool} is not null)"); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.HeaderArrayFromPool});"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } else { writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] - static extern void Dispose_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, void** data); - - fixed(void* _{{raw}} = {{names.Span}}) - { - Dispose_{{raw}}(null, (uint) {{names.Span}}.Length, (void**)_{{raw}}); - } - """); + writer.WriteLine("[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = \"Dispose\")]"); + writer.WriteLine($"static extern void Dispose_{raw}([UnsafeAccessorType(\"{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}\")] object _, uint length, void** data);"); + writer.WriteLine(); + writer.WriteLine($"fixed(void* _{raw} = {names.Span})"); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine($"Dispose_{raw}(null, (uint) {names.Span}.Length, (void**)_{raw});"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - if ({{names.ArrayFromPool}} is not null) - { - global::System.Buffers.ArrayPool.Shared.Return({{names.ArrayFromPool}}); - } - """); - } - writer.WriteLine(" }"); + writer.WriteLine($"if ({names.ArrayFromPool} is not null)"); + writer.WriteLine("{"); + writer.IncreaseIndent(); + writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.ArrayFromPool});"); + writer.DecreaseIndent(); + writer.WriteLine("}"); + } + writer.DecreaseIndent(); + writer.WriteLine("}"); } + writer.DecreaseIndent(); + writer.DecreaseIndent(); writer.WriteLine(isMultiline: true, """ } } From 98c637fe4b175e95c375a32e14daf35b738d367e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 17:55:33 -0700 Subject: [PATCH 116/171] Inline standalone manual-indent write in struct ConvertToManaged Replaces the standalone `writer.Write(" ");` followed by a conditional `writer.Write($"{fname} = ")` in the ConvertToManaged field loop with a single ternary `Write` call. This mirrors the existing pattern in ConvertToUnmanaged at line 106 (which already inlines the indent + field assignment into a single `Write`). Byte-identical output across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/StructEnumMarshallerFactory.cs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 26a828e02..abd617cb0 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -159,12 +159,7 @@ public static unsafe class {{nameStripped}}Marshaller writer.WriteLineIf(!first, ","); first = false; - writer.Write(" "); - - if (useObjectInitializer) - { - writer.Write($"{fname} = "); - } + writer.Write(useObjectInitializer ? $" {fname} = " : " "); if (ft.IsString()) { From 857a70b73392b830c5cf758cf4826c6dc58521a4 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 22:47:49 -0700 Subject: [PATCH 117/171] Move IncreaseIndent earlier and consolidate consecutive WriteLines in EmitFactoryCallbackClass Moves one of the two writer.IncreaseIndent() calls earlier (before the Invoke method signature emission) so the signature raw strings no longer carry leading whitespace in their content lines. The final close also splits its multiline raw string into separate WriteLine calls so the writer indent stack drives the indent. Consolidates 7 runs of consecutive single-line `writer.WriteLine` calls into multiline raw strings: - L171-173: `[UnsafeAccessor] / static extern / using` for generic instance params - L268-273: `Unsafe.SkipInit / nint[] / Span` setup for non-blittable arrays - L277-288: `Unsafe.SkipInit` setup for HString headers and pinned handles - L442-446: `HStringArrayMarshaller.ConvertToUnmanagedUnsafe` call - L451-453: `[UnsafeAccessor] / static extern / call` for CopyToUnmanaged - L583-587: `} / finally / {` triple - L619-624: `[UnsafeAccessor] / static extern / fixed` for Dispose Also updates `RefModeStubFactory.EmitRefModeInvokeBody` to enter at the class-content indent level (instead of class-scope level) and to use `IncreaseIndent` / `DecreaseIndent` for the inner method body and outer class body braces. This matches the new caller convention in `EmitFactoryCallbackClass`. Byte-identical output across pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../ConstructorFactory.FactoryCallbacks.cs | 120 ++++++++++-------- .../Factories/RefModeStubFactory.cs | 16 ++- 2 files changed, 78 insertions(+), 58 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index af2182cff..e13f78d75 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -80,27 +80,30 @@ private sealed class {{callbackName}} : {{baseClass}} [MethodImpl(MethodImplOptions.NoInlining)] """); + + writer.IncreaseIndent(); + if (isComposable) { // Composable Invoke signature is multi-line and includes baseInterface (in) + // innerInterface (out). writer.WriteLine(isMultiline: true, """ - public override unsafe void Invoke( - WindowsRuntimeActivationArgsReference additionalParameters, - WindowsRuntimeObject baseInterface, - out void* innerInterface, - out void* retval) - { + public override unsafe void Invoke( + WindowsRuntimeActivationArgsReference additionalParameters, + WindowsRuntimeObject baseInterface, + out void* innerInterface, + out void* retval) + { """); } else { // Sealed Invoke signature is multi-line.. writer.WriteLine(isMultiline: true, """ - public override unsafe void Invoke( - WindowsRuntimeActivationArgsReference additionalParameters, - out void* retval) - { + public override unsafe void Invoke( + WindowsRuntimeActivationArgsReference additionalParameters, + out void* retval) + { """); } @@ -111,12 +114,13 @@ public override unsafe void Invoke( return; } - writer.IncreaseIndent(); writer.IncreaseIndent(); - writer.WriteLine($"using WindowsRuntimeObjectReferenceValue activationFactoryValue = {factoryObjRefName}.AsValue();"); - writer.WriteLine("void* ThisPtr = activationFactoryValue.GetThisPtrUnsafe();"); - writer.WriteLine($"ref readonly {argsName} args = ref additionalParameters.GetValueRefUnsafe<{argsName}>();"); + writer.WriteLine(isMultiline: true, $$""" + using WindowsRuntimeObjectReferenceValue activationFactoryValue = {{factoryObjRefName}}.AsValue(); + void* ThisPtr = activationFactoryValue.GetThisPtrUnsafe(); + ref readonly {{argsName}} args = ref additionalParameters.GetValueRefUnsafe<{{argsName}}>(); + """); // Bind each arg from the args struct to a local of its ABI-marshalable input type. // Bind arg locals. @@ -168,9 +172,11 @@ public override unsafe void Invoke( string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine("[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = \"ConvertToUnmanaged\")]"); - writer.WriteLine($"static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{raw}([UnsafeAccessorType(\"{interopTypeName}\")] object _, {projectedTypeName} value);"); - writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{raw} = ConvertToUnmanaged_{raw}(null, {pname});"); + writer.WriteLine(isMultiline: true, $$""" + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] + static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); + using WindowsRuntimeObjectReferenceValue __{{raw}} = ConvertToUnmanaged_{{raw}}(null, {{pname}}); + """); } // For runtime class / object params, emit `using WindowsRuntimeObjectReferenceValue __ = ...ConvertToUnmanaged();` @@ -266,26 +272,30 @@ public override unsafe void Invoke( string callName = IdentifierEscaping.EscapeIdentifier(raw); ArrayTempNames names = new(raw); writer.WriteLine(); - writer.WriteLine($"Unsafe.SkipInit(out InlineArray16 {names.InlineArray});"); - writer.WriteLine($"nint[] {names.ArrayFromPool} = null;"); - writer.WriteLine($"Span {names.Span} = {callName}.Length <= 16"); - writer.WriteLine($" ? {names.InlineArray}[..{callName}.Length]"); - writer.WriteLine($" : ({names.ArrayFromPool} = global::System.Buffers.ArrayPool.Shared.Rent({callName}.Length));"); + writer.WriteLine(isMultiline: true, $$""" + Unsafe.SkipInit(out InlineArray16 {{names.InlineArray}}); + nint[] {{names.ArrayFromPool}} = null; + Span {{names.Span}} = {{callName}}.Length <= 16 + ? {{names.InlineArray}}[..{{callName}}.Length] + : ({{names.ArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + """); if (szArr.BaseType.IsString()) { writer.WriteLine(); - writer.WriteLine($"Unsafe.SkipInit(out InlineArray16 {names.InlineHeaderArray});"); - writer.WriteLine($"HStringHeader[] {names.HeaderArrayFromPool} = null;"); - writer.WriteLine($"Span {names.HeaderSpan} = {callName}.Length <= 16"); - writer.WriteLine($" ? {names.InlineHeaderArray}[..{callName}.Length]"); - writer.WriteLine($" : ({names.HeaderArrayFromPool} = global::System.Buffers.ArrayPool.Shared.Rent({callName}.Length));"); - writer.WriteLine(); - writer.WriteLine($"Unsafe.SkipInit(out InlineArray16 {names.InlinePinnedHandleArray});"); - writer.WriteLine($"nint[] {names.PinnedHandleArrayFromPool} = null;"); - writer.WriteLine($"Span {names.PinnedHandleSpan} = {callName}.Length <= 16"); - writer.WriteLine($" ? {names.InlinePinnedHandleArray}[..{callName}.Length]"); - writer.WriteLine($" : ({names.PinnedHandleArrayFromPool} = global::System.Buffers.ArrayPool.Shared.Rent({callName}.Length));"); + writer.WriteLine(isMultiline: true, $$""" + Unsafe.SkipInit(out InlineArray16 {{names.InlineHeaderArray}}); + HStringHeader[] {{names.HeaderArrayFromPool}} = null; + Span {{names.HeaderSpan}} = {{callName}}.Length <= 16 + ? {{names.InlineHeaderArray}}[..{{callName}}.Length] + : ({{names.HeaderArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + + Unsafe.SkipInit(out InlineArray16 {{names.InlinePinnedHandleArray}}); + nint[] {{names.PinnedHandleArrayFromPool}} = null; + Span {{names.PinnedHandleSpan}} = {{callName}}.Length <= 16 + ? {{names.InlinePinnedHandleArray}}[..{{callName}}.Length] + : ({{names.PinnedHandleArrayFromPool}} = global::System.Buffers.ArrayPool.Shared.Rent({{callName}}.Length)); + """); } } @@ -439,18 +449,22 @@ public override unsafe void Invoke( if (szArr.BaseType.IsString()) { - writer.WriteLine("HStringArrayMarshaller.ConvertToUnmanagedUnsafe("); - writer.WriteLine($" source: {pname},"); - writer.WriteLine($" hstringHeaders: (HStringHeader*) _{raw}_inlineHeaderArray,"); - writer.WriteLine($" hstrings: {names.Span},"); - writer.WriteLine($" pinnedGCHandles: {names.PinnedHandleSpan});"); + writer.WriteLine(isMultiline: true, $$""" + HStringArrayMarshaller.ConvertToUnmanagedUnsafe( + source: {{pname}}, + hstringHeaders: (HStringHeader*) _{{raw}}_inlineHeaderArray, + hstrings: {{names.Span}}, + pinnedGCHandles: {{names.PinnedHandleSpan}}); + """); } else { WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - writer.WriteLine("[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = \"CopyToUnmanaged\")]"); - writer.WriteLine($"static extern void CopyToUnmanaged_{raw}([UnsafeAccessorType(\"{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}\")] object _, ReadOnlySpan<{elementProjected}> span, uint length, void** data);"); - writer.WriteLine($"CopyToUnmanaged_{raw}(null, {pname}, (uint){pname}.Length, (void**)_{raw});"); + writer.WriteLine(isMultiline: true, $$""" + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] + static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, void** data); + CopyToUnmanaged_{{raw}}(null, {{pname}}, (uint){{pname}}.Length, (void**)_{{raw}}); + """); } } @@ -568,9 +582,11 @@ public override unsafe void Invoke( if (hasNonBlittableArray) { writer.DecreaseIndent(); - writer.WriteLine("}"); - writer.WriteLine("finally"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + } + finally + { + """); writer.IncreaseIndent(); for (int i = 0; i < paramCount; i++) { @@ -617,10 +633,12 @@ public override unsafe void Invoke( else { writer.WriteLine(); - writer.WriteLine("[UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = \"Dispose\")]"); - writer.WriteLine($"static extern void Dispose_{raw}([UnsafeAccessorType(\"{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}\")] object _, uint length, void** data);"); - writer.WriteLine(); - writer.WriteLine($"fixed(void* _{raw} = {names.Span})"); + writer.WriteLine(isMultiline: true, $$""" + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] + static extern void Dispose_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, void** data); + + fixed(void* _{{raw}} = {{names.Span}}) + """); writer.WriteLine("{"); writer.IncreaseIndent(); writer.WriteLine($"Dispose_{raw}(null, (uint) {names.Span}.Length, (void**)_{raw});"); @@ -640,11 +658,9 @@ public override unsafe void Invoke( } writer.DecreaseIndent(); + writer.WriteLine("}"); writer.DecreaseIndent(); - writer.WriteLine(isMultiline: true, """ - } - } - """); + writer.WriteLine("}"); } /// diff --git a/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs b/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs index 64ccad567..b37711640 100644 --- a/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs @@ -46,13 +46,17 @@ public static void EmitSyntheticPrivateCtor(IndentedTextWriter writer, string ty /// /// Emits the body of a delegate factory Invoke method in reference projection mode. /// - /// The writer to emit to. + /// The writer to emit to. Must be at the class-content indent level on + /// entry (i.e. after the surrounding class opener and one ). + /// On exit the writer is at the class-scope indent level (both the inner method body and + /// the outer class body braces are closed by this method). public static void EmitRefModeInvokeBody(IndentedTextWriter writer) { - writer.WriteLine(isMultiline: true, """ - throw null; - } - } - """); + writer.IncreaseIndent(); + writer.WriteLine("throw null;"); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } } From 485716f81cb0ee44db0340fa3fd49bb05494ab1d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 22:49:21 -0700 Subject: [PATCH 118/171] Strip leading whitespace from UnsafeAccessor raw strings in EmitDoAbiBodyIfSimple Wraps each of the 3 `[UnsafeAccessor] / static extern / call` raw strings inside the `try` block with an `IncreaseIndent` / `DecreaseIndent` pair so the first content line no longer has 4 spaces of leading whitespace. The writer's deeper indent level combined with the now-shorter literal indents produces identical output. Also consolidates two consecutive `WriteLine` runs into multiline raw strings: - `} / catch (Exception ...) / {` triple between try and catch - `finally / {` pair at the start of the optional finally block Byte-identical output across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 38 ++++++++++++------- 1 file changed, 24 insertions(+), 14 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 79d54dfe9..b80a2b1c6 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -290,11 +290,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection dataCastExpr = "(void**)" + ptr; } + writer.IncreaseIndent(); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] - static extern void CopyToManaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); - CopyToManaged_{{raw}}(null, __{{raw}}Size, {{dataCastExpr}}, __{{raw}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] + static extern void CopyToManaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, {{dataParamType}}, Span<{{elementProjected}}> span); + CopyToManaged_{{raw}}(null, __{{raw}}Size, {{dataCastExpr}}, __{{raw}}); """); + writer.DecreaseIndent(); } // For generic instance ABI input parameters, emit local UnsafeAccessor delegates and locals @@ -317,11 +319,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string callName = IdentifierEscaping.EscapeIdentifier(rawName); string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); + writer.IncreaseIndent(); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{projectedTypeName}} ConvertToManaged_arg_{{rawName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - var __arg_{{rawName}} = ConvertToManaged_arg_{{rawName}}(null, {{callName}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] + static extern {{projectedTypeName}} ConvertToManaged_arg_{{rawName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); + var __arg_{{rawName}} = ConvertToManaged_arg_{{rawName}}(null, {{callName}}); """); + writer.DecreaseIndent(); } } @@ -530,11 +534,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // complex structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); + writer.IncreaseIndent(); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{elementAbi}}* data); - CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, ({{elementAbi}}*){{ptr}}); + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] + static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{elementAbi}}* data); + CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, ({{elementAbi}}*){{ptr}}); """); + writer.DecreaseIndent(); } if (rt is not null) @@ -600,9 +606,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection writer.WriteLine("return 0;"); writer.DecreaseIndent(); - writer.WriteLine("}"); - writer.WriteLine("catch (Exception __exception__)"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + } + catch (Exception __exception__) + { + """); writer.IncreaseIndent(); writer.WriteLine("return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__);"); writer.DecreaseIndent(); @@ -636,8 +644,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (hasNonBlittableArrayDoAbi) { - writer.WriteLine("finally"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + finally + { + """); writer.IncreaseIndent(); for (int i = 0; i < sig.Parameters.Count; i++) { From dfd1ae6713178287765940e265c8ffcef29511cc Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 22:56:56 -0700 Subject: [PATCH 119/171] Restructure WriteStructEnumMarshallerClass and tidy if-block emissions Restructures `WriteStructEnumMarshallerClass` to use the writer's indent stack for class scope, method scope, and nested initializer scope: - After class opener: `writer.IncreaseIndent()` to enter class content. Strips 4 sp from all class-content raw strings (method signatures, method bodies). - For ConvertToUnmanaged / ConvertToManaged field-loop emissions: `IncreaseIndent` twice to reach the inner-initializer indent so `writer.Write($"{fname} = ")` no longer carries 12 sp of literal indent. - Method transitions (`};`/`}` close + next method signature) are split into individual `WriteLine` calls with `DecreaseIndent` so each emission starts at zero literal indent. - Dispose body: `IncreaseIndent` after the method opener; strips the 8 sp literal prefix from each cleanup line. - `ComWrappersMarshallerAttribute.CreateObject` body: split the closing raw string and use `IncreaseIndent` for the body content so the `return ...` line no longer carries 8 sp of literal indent. Also tidies `EmitFactoryCallbackClass` and `EmitDoAbiBodyIfSimple` to use `using (writer.WriteBlock())` for the per-array `if (X is not null) { ArrayPool... }` cleanup blocks in finally scope. This replaces the manual `WriteLine("{") / IncreaseIndent / ... / DecreaseIndent / WriteLine("}")` pattern with a single `using` scope, which makes the structural intent explicit and removes 5 runs of consecutive `writer.WriteLine` calls. Byte-identical output across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 9 +- .../ConstructorFactory.FactoryCallbacks.cs | 36 ++++---- .../Factories/StructEnumMarshallerFactory.cs | 89 +++++++++++-------- 3 files changed, 71 insertions(+), 63 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index b80a2b1c6..3a9d9f671 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -673,11 +673,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); writer.WriteLine(); writer.WriteLine($"if (__{raw}_arrayFromPool is not null)"); - writer.WriteLine("{"); - writer.IncreaseIndent(); - writer.WriteLine($"global::System.Buffers.ArrayPool<{elementProjected}>.Shared.Return(__{raw}_arrayFromPool);"); - writer.DecreaseIndent(); - writer.WriteLine("}"); + using (writer.WriteBlock()) + { + writer.WriteLine($"global::System.Buffers.ArrayPool<{elementProjected}>.Shared.Return(__{raw}_arrayFromPool);"); + } } writer.DecreaseIndent(); writer.WriteLine("}"); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index e13f78d75..e9e39b3c7 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -617,18 +617,16 @@ public override unsafe void Invoke( writer.WriteLine($"HStringArrayMarshaller.Dispose({names.PinnedHandleSpan});"); writer.WriteLine(); writer.WriteLine($"if ({names.PinnedHandleArrayFromPool} is not null)"); - writer.WriteLine("{"); - writer.IncreaseIndent(); - writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.PinnedHandleArrayFromPool});"); - writer.DecreaseIndent(); - writer.WriteLine("}"); + using (writer.WriteBlock()) + { + writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.PinnedHandleArrayFromPool});"); + } writer.WriteLine(); writer.WriteLine($"if ({names.HeaderArrayFromPool} is not null)"); - writer.WriteLine("{"); - writer.IncreaseIndent(); - writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.HeaderArrayFromPool});"); - writer.DecreaseIndent(); - writer.WriteLine("}"); + using (writer.WriteBlock()) + { + writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.HeaderArrayFromPool});"); + } } else { @@ -639,19 +637,17 @@ public override unsafe void Invoke( fixed(void* _{{raw}} = {{names.Span}}) """); - writer.WriteLine("{"); - writer.IncreaseIndent(); - writer.WriteLine($"Dispose_{raw}(null, (uint) {names.Span}.Length, (void**)_{raw});"); - writer.DecreaseIndent(); - writer.WriteLine("}"); + using (writer.WriteBlock()) + { + writer.WriteLine($"Dispose_{raw}(null, (uint) {names.Span}.Length, (void**)_{raw});"); + } } writer.WriteLine(); writer.WriteLine($"if ({names.ArrayFromPool} is not null)"); - writer.WriteLine("{"); - writer.IncreaseIndent(); - writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.ArrayFromPool});"); - writer.DecreaseIndent(); - writer.WriteLine("}"); + using (writer.WriteBlock()) + { + writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.ArrayFromPool});"); + } } writer.DecreaseIndent(); writer.WriteLine("}"); diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index abd617cb0..8c833ff7f 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -85,15 +85,18 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P public static unsafe class {{nameStripped}}Marshaller { """); + writer.IncreaseIndent(); if (isComplexStruct) { // ConvertToUnmanaged: build ABI struct from projected struct via per-field marshalling. writer.WriteLine(isMultiline: true, $$""" - public static {{abi}} ConvertToUnmanaged({{projected}} value) - { - return new() { + public static {{abi}} ConvertToUnmanaged({{projected}} value) + { + return new() { """); + writer.IncreaseIndent(); + writer.IncreaseIndent(); bool first = true; foreach (FieldDefinition field in GetInstanceFields(type)) { @@ -103,7 +106,7 @@ public static unsafe class {{nameStripped}}Marshaller writer.WriteLineIf(!first, ","); first = false; - writer.Write($" {fname} = "); + writer.Write($"{fname} = "); if (ft.IsString()) { @@ -143,13 +146,17 @@ public static unsafe class {{nameStripped}}Marshaller // primary constructor on projected struct types). bool useObjectInitializer = context.Settings.Component; writer.WriteLine(); + writer.DecreaseIndent(); + writer.WriteLine("};"); + writer.DecreaseIndent(); + writer.WriteLine("}"); writer.WriteLine(isMultiline: true, $$""" - }; - } - public static {{projected}} ConvertToManaged({{abi}} value) - { - return new {{projected}}{{(useObjectInitializer ? "(){" : "(")}} + public static {{projected}} ConvertToManaged({{abi}} value) + { + return new {{projected}}{{(useObjectInitializer ? "(){" : "(")}} """); + writer.IncreaseIndent(); + writer.IncreaseIndent(); first = true; foreach (FieldDefinition field in GetInstanceFields(type)) { @@ -159,7 +166,7 @@ public static unsafe class {{nameStripped}}Marshaller writer.WriteLineIf(!first, ","); first = false; - writer.Write(useObjectInitializer ? $" {fname} = " : " "); + writer.Write(useObjectInitializer ? $"{fname} = " : ""); if (ft.IsString()) { @@ -194,12 +201,15 @@ public static unsafe class {{nameStripped}}Marshaller } } writer.WriteLine(); - writer.WriteLine(useObjectInitializer ? " };" : " );"); - writer.WriteLine(" }"); + writer.DecreaseIndent(); + writer.WriteLine(useObjectInitializer ? "};" : ");"); + writer.DecreaseIndent(); + writer.WriteLine("}"); writer.WriteLine(isMultiline: true, $$""" - public static void Dispose({{abi}} value) - { + public static void Dispose({{abi}} value) + { """); + writer.IncreaseIndent(); foreach (FieldDefinition field in GetInstanceFields(type)) { string fname = field.Name?.Value ?? ""; @@ -207,7 +217,7 @@ public static void Dispose({{abi}} value) if (ft.IsString()) { - writer.WriteLine($" HStringMarshaller.Free(value.{fname});"); + writer.WriteLine($"HStringMarshaller.Free(value.{fname});"); } else if (ft.IsHResultException()) { @@ -229,14 +239,15 @@ public static void Dispose({{abi}} value) // Nested non-blittable struct: dispose via its Marshaller. string nestedNs = fieldStructTd3.Namespace?.Value ?? string.Empty; string nestedNm = IdentifierEscaping.StripBackticks(fieldStructTd3.Name?.Value ?? string.Empty); - writer.WriteLine($" global::ABI.{nestedNs}.{nestedNm}Marshaller.Dispose(value.{fname});"); + writer.WriteLine($"global::ABI.{nestedNs}.{nestedNm}Marshaller.Dispose(value.{fname});"); } else if (AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out _)) { - writer.WriteLine($" WindowsRuntimeUnknownMarshaller.Free(value.{fname});"); + writer.WriteLine($"WindowsRuntimeUnknownMarshaller.Free(value.{fname});"); } } - writer.WriteLine(" }"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } // BoxToUnmanaged: same pattern for all (enum, almost-blittable, complex, mapped struct). @@ -249,10 +260,10 @@ public static void Dispose({{abi}} value) WriteIidReferenceExpressionCallback boxIidRef = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(isMultiline: true, $$""" - public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? value) - { - return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.{{boxFlags}}, in {{boxIidRef}}); - } + public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? value) + { + return WindowsRuntimeValueTypeMarshaller.BoxToUnmanaged(value, CreateComInterfaceFlags.{{boxFlags}}, in {{boxIidRef}}); + } """); // UnboxToManaged: simple for almost-blittable and mapped structs; for complex, unbox to @@ -262,23 +273,24 @@ public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? v if (isComplexStruct) { writer.WriteLine(isMultiline: true, $$""" - public static {{projected}}? UnboxToManaged(void* value) - { - {{abi}}? abi = WindowsRuntimeValueTypeMarshaller.UnboxToManaged<{{abi}}>(value); - return abi.HasValue ? ConvertToManaged(abi.GetValueOrDefault()) : null; - } + public static {{projected}}? UnboxToManaged(void* value) + { + {{abi}}? abi = WindowsRuntimeValueTypeMarshaller.UnboxToManaged<{{abi}}>(value); + return abi.HasValue ? ConvertToManaged(abi.GetValueOrDefault()) : null; + } """); } else { writer.WriteLine(isMultiline: true, $$""" - public static {{projected}}? UnboxToManaged(void* value) - { - return WindowsRuntimeValueTypeMarshaller.UnboxToManaged<{{projected}}>(value); - } + public static {{projected}}? UnboxToManaged(void* value) + { + return WindowsRuntimeValueTypeMarshaller.UnboxToManaged<{{projected}}>(value); + } """); } + writer.DecreaseIndent(); writer.WriteLine("}"); writer.WriteLine(); @@ -347,20 +359,21 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper { wrapperFlags = CreatedWrapperFlags.NonWrapping; """); + writer.IncreaseIndent(); + writer.IncreaseIndent(); if (isComplexStruct) { WriteTypedefNameCallback abiFq = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, true); - writer.WriteLine($" return {nameStripped}Marshaller.ConvertToManaged(WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{abiFq}>(value, in {iidRefExpr}));"); + writer.WriteLine($"return {nameStripped}Marshaller.ConvertToManaged(WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{abiFq}>(value, in {iidRefExpr}));"); } else { - writer.WriteLine($" return WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{projected}>(value, in {iidRefExpr});"); + writer.WriteLine($"return WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{projected}>(value, in {iidRefExpr});"); } - - writer.WriteLine(isMultiline: true, """ - } - } - """); + writer.DecreaseIndent(); + writer.WriteLine("}"); + writer.DecreaseIndent(); + writer.WriteLine("}"); } else { From 714580cd3f710c1cd1e980f8313670173fc0aab7 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:01:08 -0700 Subject: [PATCH 120/171] Revert unnecessary raw-string splits and WriteBlock anti-patterns The previous commits split a few multiline raw strings into separate `WriteLine` calls and converted simple `if (X is not null) { ... }` fixed-content blocks to `using (writer.WriteBlock()) { ... }`. Per follow-up guidance: - A multiline raw string is only "wrong" when *all* of its content lines have non-zero leading whitespace. If any content line is at zero leading whitespace, the raw string is fine as-is and should not be split. - `writer.WriteBlock()` is for blocks where the body content is not fixed. For constant single-statement bodies, the whole `if/{/body/}` belongs in a single multiline raw string. Reverts: - `RefModeStubFactory.EmitRefModeInvokeBody`: restore the single raw string `throw null; / } / }` and update the caller in `EmitFactoryCallbackClass` to `DecreaseIndent` before invoking it. - `EmitFactoryCallbackClass` final close: restore the single raw string `} / }` after two `DecreaseIndent` calls. - `EmitDoAbiBodyIfSimple` try opener: restore the single raw string `try / {` followed by `IncreaseIndent`. - `EmitDoAbiBodyIfSimple` per-array finally cleanup: replace the `writer.WriteBlock()` pattern with a single raw string containing the full `if/{/global::System.Buffers.ArrayPool.../}` block. - `EmitFactoryCallbackClass` per-array finally cleanups: collapse the `HStringArrayMarshaller.Dispose / if/{/ArrayPool.Return/}`, `[UnsafeAccessor] / fixed/{/Dispose_/}`, and final `if/{/Array Pool.Return/}` sequences back into single multiline raw strings. Byte-identical output across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 17 ++++--- .../ConstructorFactory.FactoryCallbacks.cs | 51 ++++++++++--------- .../Factories/RefModeStubFactory.cs | 18 +++---- 3 files changed, 45 insertions(+), 41 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 3a9d9f671..61b8fb25c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -246,8 +246,10 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection """); } } - writer.WriteLine("try"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + try + { + """); writer.IncreaseIndent(); // For non-blittable PassArray params (read-only input arrays), emit CopyToManaged_ @@ -672,11 +674,12 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); writer.WriteLine(); - writer.WriteLine($"if (__{raw}_arrayFromPool is not null)"); - using (writer.WriteBlock()) - { - writer.WriteLine($"global::System.Buffers.ArrayPool<{elementProjected}>.Shared.Return(__{raw}_arrayFromPool);"); - } + writer.WriteLine(isMultiline: true, $$""" + if (__{{raw}}_arrayFromPool is not null) + { + global::System.Buffers.ArrayPool<{{elementProjected}}>.Shared.Return(__{{raw}}_arrayFromPool); + } + """); } writer.DecreaseIndent(); writer.WriteLine("}"); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index e9e39b3c7..45a377f85 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -110,6 +110,7 @@ public override unsafe void Invoke( // Invoke body is just 'throw null;' (no factory dispatch, no marshalling). if (context.Settings.ReferenceProjection) { + writer.DecreaseIndent(); RefModeStubFactory.EmitRefModeInvokeBody(writer); return; } @@ -614,19 +615,19 @@ public override unsafe void Invoke( if (szArr.BaseType.IsString()) { writer.WriteLine(); - writer.WriteLine($"HStringArrayMarshaller.Dispose({names.PinnedHandleSpan});"); - writer.WriteLine(); - writer.WriteLine($"if ({names.PinnedHandleArrayFromPool} is not null)"); - using (writer.WriteBlock()) - { - writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.PinnedHandleArrayFromPool});"); - } - writer.WriteLine(); - writer.WriteLine($"if ({names.HeaderArrayFromPool} is not null)"); - using (writer.WriteBlock()) - { - writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.HeaderArrayFromPool});"); - } + writer.WriteLine(isMultiline: true, $$""" + HStringArrayMarshaller.Dispose({{names.PinnedHandleSpan}}); + + if ({{names.PinnedHandleArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool.Shared.Return({{names.PinnedHandleArrayFromPool}}); + } + + if ({{names.HeaderArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool.Shared.Return({{names.HeaderArrayFromPool}}); + } + """); } else { @@ -636,27 +637,29 @@ public override unsafe void Invoke( static extern void Dispose_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, void** data); fixed(void* _{{raw}} = {{names.Span}}) + { + Dispose_{{raw}}(null, (uint) {{names.Span}}.Length, (void**)_{{raw}}); + } """); - using (writer.WriteBlock()) - { - writer.WriteLine($"Dispose_{raw}(null, (uint) {names.Span}.Length, (void**)_{raw});"); - } } writer.WriteLine(); - writer.WriteLine($"if ({names.ArrayFromPool} is not null)"); - using (writer.WriteBlock()) - { - writer.WriteLine($"global::System.Buffers.ArrayPool.Shared.Return({names.ArrayFromPool});"); - } + writer.WriteLine(isMultiline: true, $$""" + if ({{names.ArrayFromPool}} is not null) + { + global::System.Buffers.ArrayPool.Shared.Return({{names.ArrayFromPool}}); + } + """); } writer.DecreaseIndent(); writer.WriteLine("}"); } writer.DecreaseIndent(); - writer.WriteLine("}"); writer.DecreaseIndent(); - writer.WriteLine("}"); + writer.WriteLine(isMultiline: true, """ + } + } + """); } /// diff --git a/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs b/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs index b37711640..19f6b68f3 100644 --- a/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/RefModeStubFactory.cs @@ -46,17 +46,15 @@ public static void EmitSyntheticPrivateCtor(IndentedTextWriter writer, string ty /// /// Emits the body of a delegate factory Invoke method in reference projection mode. /// - /// The writer to emit to. Must be at the class-content indent level on - /// entry (i.e. after the surrounding class opener and one ). - /// On exit the writer is at the class-scope indent level (both the inner method body and - /// the outer class body braces are closed by this method). + /// The writer to emit to. Must be at the class-scope indent level on + /// entry (i.e. the inner method body and the outer class body braces are both closed by + /// this method). public static void EmitRefModeInvokeBody(IndentedTextWriter writer) { - writer.IncreaseIndent(); - writer.WriteLine("throw null;"); - writer.DecreaseIndent(); - writer.WriteLine("}"); - writer.DecreaseIndent(); - writer.WriteLine("}"); + writer.WriteLine(isMultiline: true, """ + throw null; + } + } + """); } } From 8627af03e16b9e6c9083a2ab33d4347c745a7fd2 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:29:20 -0700 Subject: [PATCH 121/171] Fix HasNonObjectBaseType incorrectly returning true for System.Object base MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Commit `6b463021` (Refactor type/name helpers and accessors) rewrote `HasNonObjectBaseType` to use a pattern match against `CorLibTypeSignature { ElementType: ElementType.Object }`. However, `TypeDefinition.BaseType` is an `ITypeDefOrRef` (typically a `TypeRef` to `System.Object` for WinRT runtime classes), not a `CorLibTypeSignature`. The pattern therefore never matched, and the method returned `true` for every type with any non-null base type — including all WinRT runtime classes whose base is `System.Object`. This caused `ClassFactory` to emit a spurious `|| base.IsOverridableInterface(in iid)` clause on every projected runtime class's `IsOverridableInterface` override. The base `WindowsRuntimeObject.IsOverridableInterface` throws via `UnreachableException.Throw()`, so any composable class constructor that called into `GetOrCreateComInterfaceForObject` (e.g. `new WarningClass()` from `UnitTest.UnitTestCSharp.TestOverridable`) unwound through the throwing base call and failed on AOT publish. Restores the pre-refactor behavior by comparing the namespace + name via the `Names()` extension (the same pattern already used in `InterfaceFactory`, `AbiTypeHelpers`, and `TypeSemantics`). Also drops the now-unused `AsmResolver.PE.DotNet.Metadata.Tables` using. After this fix, projected `IsOverridableInterface` overrides on direct-`System.Object` bases (such as `WarningClass`) once again emit just `=> false` or just the overridable IID clause, matching the green CI output at `60c7e69b`. Derived projected classes whose base is another generated WinRT class (such as `DerivedCustomEquals : UnSealedCustomEquals`) keep the correct `|| base.IsOverridableInterface(in iid)` chain. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeDefinitionExtensions.cs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 93683a05a..1853334f2 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -6,7 +6,6 @@ using System.Globalization; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; -using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Metadata; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; @@ -149,7 +148,14 @@ public bool HasDefaultConstructor() /// public bool HasNonObjectBaseType() { - return type.BaseType is not (null or CorLibTypeSignature { ElementType: ElementType.Object }); + if (type.BaseType is not { } baseType) + { + return false; + } + + (string ns, string name) = baseType.Names(); + + return !(ns == "System" && name == "Object"); } /// From 3df040c203ebcad4f9175884a35de1f890843f84 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:32:09 -0700 Subject: [PATCH 122/171] Remove extra blank line in DoAbi.cs Remove an unnecessary blank line between the foreach declaration and its body in src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs. No functional changes; purely formatting cleanup. --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 61b8fb25c..081b8c4f8 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -514,7 +514,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // which emits 'CopyToUnmanaged_(null, __, __Size, (T*))'. // Blittable element types don't need this — the Span wraps the native buffer directly. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.FillArray)) - { if (p.Type is not SzArrayTypeSignature szFA) From 0c3a0999dc19e353ade36a7f849060608113abc0 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:35:46 -0700 Subject: [PATCH 123/171] Normalize indentation in AbiMethodBodyFactory Normalize indentation and remove extraneous blank lines in src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs. Adjusts multi-line WriteLine blocks (UnsafeAccessor declarations, array marshalling code, and related spans) and clears stray blank lines around foreach blocks to produce consistent generated code formatting. No functional changes. --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 43 ++++++++----------- 1 file changed, 18 insertions(+), 25 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 081b8c4f8..86198ceb8 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -70,9 +70,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(rt!, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt!, false); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - """); + """); writer.WriteLine(); } @@ -80,7 +80,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // ConvertToUnmanaged_ wraps the projected value into a WindowsRuntimeObjectReferenceValue. // The body's writeback later references these already-declared accessors. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - { TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); @@ -94,9 +93,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(uOut, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - """); + """); writer.WriteLine(); } @@ -104,7 +103,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // top of the method body, before locals and the try block. The actual call sites later // in the body reference these already-declared accessors. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - { string raw = p.GetRawName(); @@ -114,9 +112,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, sza.BaseType); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern void ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); - """); + """); writer.WriteLine(); } @@ -126,9 +124,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, retSzHoist.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(retSzHoist.BaseType); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] static extern void ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); - """); + """); writer.WriteLine(); } @@ -153,9 +151,9 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (returnIsReceiveArrayDoAbi) { writer.WriteLine(isMultiline: true, $$""" - *{{retParamName}} = default; + *{{retParamName}} = default; *{{retSizeParamName}} = default; - """); + """); } else { @@ -168,15 +166,14 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // perspective. Do NOT zero * (it's the input value) and do NOT declare a local // (we read directly via *). foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - { string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); writer.WriteLine($"*{ptr} = default;"); } - foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) + foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) { string raw = p.GetRawName(); @@ -191,7 +188,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // and declare a managed array local. The managed call passes 'out __' and after // the call we copy to the ABI buffer via UnsafeAccessor. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - { string raw = p.GetRawName(); @@ -238,12 +234,12 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Non-blittable element: InlineArray16 + ArrayPool with size from ABI. writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - Unsafe.SkipInit(out InlineArray16<{{elementProjected}}> __{{raw}}_inlineArray); - {{elementProjected}}[] __{{raw}}_arrayFromPool = null; - Span<{{elementProjected}}> __{{raw}} = __{{raw}}Size <= 16 - ? __{{raw}}_inlineArray[..(int)__{{raw}}Size] - : (__{{raw}}_arrayFromPool = global::System.Buffers.ArrayPool<{{elementProjected}}>.Shared.Rent((int)__{{raw}}Size)); - """); + Unsafe.SkipInit(out InlineArray16<{{elementProjected}}> __{{raw}}_inlineArray); + {{elementProjected}}[] __{{raw}}_arrayFromPool = null; + Span<{{elementProjected}}> __{{raw}} = __{{raw}}Size <= 16 + ? __{{raw}}_inlineArray[..(int)__{{raw}}Size] + : (__{{raw}}_arrayFromPool = global::System.Buffers.ArrayPool<{{elementProjected}}>.Shared.Rent((int)__{{raw}}Size)); + """); } } writer.WriteLine(isMultiline: true, """ @@ -257,7 +253,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // delegate sees. For FillArray params, the buffer is fresh storage the user delegate // fills — the post-call writeback loop handles that. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.PassArray)) - { if (p.Type is not SzArrayTypeSignature szArr) @@ -446,7 +441,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // After call: write back out params to caller's pointer. // NOTE: Ref params (WinRT 'in T') are read-only inputs — never written back. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) - { string raw = p.GetRawName(); @@ -500,7 +494,6 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // After call: for ReceiveArray params, emit ConvertToUnmanaged_ call (the // [UnsafeAccessor] declaration was hoisted to the top of the method body). foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.ReceiveArray)) - { string raw = p.GetRawName(); @@ -537,7 +530,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection writer.IncreaseIndent(); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{elementAbi}}* data); CopyToUnmanaged_{{raw}}(null, __{{raw}}, __{{raw}}Size, ({{elementAbi}}*){{ptr}}); """); From fe2b84a6bcddd036b6af926678b4c78b78272112 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:47:08 -0700 Subject: [PATCH 124/171] Consolidate constant-content WriteLine runs into multiline raw strings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per follow-up guidance: `writer.WriteBlock()` and split-emission patterns are only appropriate when the inner content is dynamic. For runs of consecutive `writer.WriteLine` calls with fixed (constant) content, a single multiline raw string is more readable. Consolidations applied (all byte-identical output across the pushnot, everything-with-ui, and windows regen scenarios): - `EmitAbiMethodBodyIfSimple` (RcwCaller.cs): - Method body opener (`{ / using thisValue / void* ThisPtr`) → single multiline + `IncreaseIndent`. - `try / {` opener pair → single multiline + `IncreaseIndent`. - `} / finally` close-try + finally-opener pair → single multiline + `WriteBlock` for the dynamic finally body. - `EmitDoAbiBodyIfSimple` (DoAbi.cs): - `return 0; / } / catch (...) / { / return Restricted...; / }` full try-closer + catch block (constant content) collapsed into one multiline raw string. The previous form had a stray `WriteLine("return 0;")` + `DecreaseIndent` + 3-line multiline + `IncreaseIndent` + `WriteLine` + `DecreaseIndent` + `WriteLine("}")` chain for what is in reality one fixed block of code. - `EmitFactoryCallbackClass` (FactoryCallbacks.cs): - `try / {` opener → single multiline + `IncreaseIndent`. - `) / {` fixed-block opener close (after the dynamic param pin list) → single multiline + `IncreaseIndent`. - `WriteStructEnumMarshallerClass` (StructEnumMarshallerFactory.cs): - ConvertToUnmanaged → ConvertToManaged transition: `};` close inner + `}` close method + `public static ... ConvertToManaged / { / return new ...` opener for next method, now one multiline with the `useObjectInitializer` interpolation baked in. - ConvertToManaged → Dispose transition: same pattern, with the `};/);` selector interpolated. - `CreateObject` method body close + ComWrappersMarshaller attribute class close (`} / }`) → single multiline. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 8 +++----- .../AbiMethodBodyFactory.RcwCaller.cs | 20 ++++++++++++------- .../ConstructorFactory.FactoryCallbacks.cs | 12 +++++++---- 3 files changed, 24 insertions(+), 16 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 86198ceb8..aa47e01b9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -598,17 +598,15 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } } - writer.WriteLine("return 0;"); writer.DecreaseIndent(); writer.WriteLine(isMultiline: true, """ + return 0; } catch (Exception __exception__) { + return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__); + } """); - writer.IncreaseIndent(); - writer.WriteLine("return RestrictedErrorInfoExceptionMarshaller.ConvertToUnmanaged(__exception__);"); - writer.DecreaseIndent(); - writer.WriteLine("}"); // For non-blittable PassArray params, emit finally block with ArrayPool.Shared.Return. bool hasNonBlittableArrayDoAbi = false; diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 9dab6ddb3..9f4da9fc3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -198,10 +198,12 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.WriteLine(); writer.IncreaseIndent(); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + { + using WindowsRuntimeObjectReferenceValue thisValue = thisReference.AsValue(); + void* ThisPtr = thisValue.GetThisPtrUnsafe(); + """); writer.IncreaseIndent(); - writer.WriteLine("using WindowsRuntimeObjectReferenceValue thisValue = thisReference.AsValue();"); - writer.WriteLine("void* ThisPtr = thisValue.GetThisPtrUnsafe();"); // Declare 'using' marshaller values for ref-type parameters (these need disposing). for (int i = 0; i < sig.Parameters.Count; i++) @@ -439,8 +441,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (needsTryFinally) { - writer.WriteLine("try"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + try + { + """); writer.IncreaseIndent(); } @@ -1097,8 +1101,10 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (needsTryFinally) { writer.DecreaseIndent(); - writer.WriteLine("}"); - writer.WriteLine("finally"); + writer.WriteLine(isMultiline: true, """ + } + finally + """); using IndentedTextWriter.Block __finallyBlock = writer.WriteBlock(); // Order matches truth: diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 45a377f85..215e6be12 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -304,8 +304,10 @@ public override unsafe void Invoke( if (hasNonBlittableArray) { - writer.WriteLine("try"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + try + { + """); writer.IncreaseIndent(); } @@ -401,8 +403,10 @@ public override unsafe void Invoke( } } - writer.WriteLine(")"); - writer.WriteLine("{"); + writer.WriteLine(isMultiline: true, """ + ) + { + """); writer.IncreaseIndent(); fixedNesting = 1; From 83acb98b7b9f5d1b3d65e352882f116388d5a15f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:52:33 -0700 Subject: [PATCH 125/171] Add blank lines above // comments not preceded by blank or '{' Per style guidance: a `//` single-line comment should always have a blank line above it (or a line whose trailing non-whitespace is `{`); it should never have a statement or expression immediately above it. This commit adds a leading blank line wherever that rule was violated across the projection writer project. Mechanical change applied via script that: - Walks every `.cs` file under `src/WinRT.Projection.Writer/`. - Tracks multi-line raw string state so comments inside emitted generator strings are left alone. - For each `//` comment line (excluding `///` XML doc), checks the previous source line. If it is non-blank, non-`{`-terminated, and not itself a `//` or `///` comment, inserts a blank line. 28 files modified; 77 blank lines inserted; zero lines removed. Build clean; generated projection output is byte-identical across the pushnot, everything-with-ui, and windows regen scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceFactory.cs | 3 +++ .../Factories/AbiInterfaceIDicFactory.cs | 4 ++++ .../Factories/AbiMethodBodyFactory.DoAbi.cs | 6 ++++++ .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 7 +++++++ src/WinRT.Projection.Writer/Factories/ClassFactory.cs | 5 +++++ .../Factories/ClassMembersFactory.WriteClassMembers.cs | 6 ++++++ .../Factories/ClassMembersFactory.WriteInterfaceMembers.cs | 3 +++ src/WinRT.Projection.Writer/Factories/ComponentFactory.cs | 2 ++ .../Factories/ConstructorFactory.AttributedTypes.cs | 1 + .../Factories/ConstructorFactory.Composable.cs | 2 ++ .../Factories/CustomAttributeFactory.cs | 1 + src/WinRT.Projection.Writer/Factories/EventTableFactory.cs | 1 + src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs | 4 ++++ .../Factories/MappedInterfaceStubFactory.cs | 4 ++++ .../Factories/StructEnumMarshallerFactory.cs | 5 +++++ .../Generation/ProjectionGenerator.GeneratedIids.cs | 1 + .../Generation/ProjectionGenerator.Namespace.cs | 1 + .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 ++ .../Helpers/AbiTypeHelpers.Blittability.cs | 1 + .../Helpers/AbiTypeHelpers.MappedTypes.cs | 1 + .../Helpers/AbiTypeHelpers.Marshallers.cs | 3 +++ src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs | 5 +++++ src/WinRT.Projection.Writer/Helpers/ArrayElementEncoder.cs | 3 +++ src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs | 1 + .../Helpers/IidExpressionGenerator.cs | 2 ++ .../Helpers/InteropTypeNameWriter.cs | 1 + src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs | 1 + src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs | 1 + 28 files changed, 77 insertions(+) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index e57a39fac..b8413abb8 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -158,6 +158,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj writer.Write(", "); string retName = AbiTypeHelpers.GetReturnParamName(sig); string retSizeName = AbiTypeHelpers.GetReturnSizeParamName(sig); + // Special handling for SzArray return types: WinRT projects them as a (uint*, T**) pair. if (sig.ReturnType is SzArrayTypeSignature retSz) { @@ -473,6 +474,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{typedefNam private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); + // exclusive to a class (and not opted into PublicExclusiveTo) or if it's marked // [ProjectionInternal]; public otherwise. bool useInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) @@ -535,6 +537,7 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj if (isFastAbiDefault) { int slot = InspectableMethodCount; + // Default interface: skip its events (they're inlined in the RCW class). segments.Add((type, slot, true)); slot += AbiTypeHelpers.CountMethods(type) + AbiTypeHelpers.GetClassHierarchyIndex(context.Cache, fastAbi!.Value.Class); diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index a4a6d89ad..12680bca5 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -91,6 +91,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( // Emit explicit-interface DIM forwarders for the BCL members so the DIC shim // satisfies them when queried via casts like '((IList)(WindowsRuntimeObject)this)'. EmitDicShimMappedBclForwarders(writer, context, rName); + // IBindableVector's IList forwarders already include the IEnumerable.GetEnumerator // forwarder (since IList : IEnumerable). Pre-add IBindableIterable to the visited // set so we don't emit a second GetEnumerator forwarder for it. We also walk the @@ -113,6 +114,7 @@ internal static void WriteInterfaceIdicImplMembersForRequiredInterfaces( string keyText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[0]), TypedefNameType.Projected, true).Format(); string valueText = TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.Get(giMap.TypeArguments[1]), TypedefNameType.Projected, true).Format(); EmitDicShimIObservableMapForwarders(writer, context, keyText, valueText); + // Mark the inherited IMap`2 / IIterable`1 as visited so they aren't re-emitted. required.MarkRequiredInterfacesVisited(context.Cache, visited); } @@ -315,12 +317,14 @@ internal static void EmitDicShimMappedBclForwarders(IndentedTextWriter writer, P switch (mappedWinRTInterfaceName) { case "IClosable": + // IClosable maps to IDisposable. Forward Dispose() to the // WindowsRuntimeObject base which has the actual implementation. writer.WriteLine(); writer.WriteLine("void global::System.IDisposable.Dispose() => ((global::System.IDisposable)(WindowsRuntimeObject)this).Dispose();"); break; case "IBindableVector": + // IList covers IList, ICollection, and IEnumerable members. writer.WriteLine(); writer.WriteLine(isMultiline: true, """ diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index aa47e01b9..0e8e6b36d 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -56,10 +56,12 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection MethodSignatureInfo.ReturnNameInfo retNames = sig.GetReturnNameInfo(); string retParamName = retNames.ValuePointer; string retSizeParamName = retNames.SizePointer; + // The local name for the unmarshalled return value uses the standard pattern // of prefixing '__' to the param name. For the default '__return_value__' param // this becomes '____return_value__'. string retLocalName = retNames.Local; + // at the TOP of the method body (before local declarations and the try block). The // actual call sites later in the body just reference the already-declared accessor. // For a generic-instance return type, the accessor is named ConvertToUnmanaged_. @@ -177,6 +179,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { string raw = p.GetRawName(); + // Use the projected (non-ABI) type for the local variable. // Strip ByRef and CustomModifier wrappers to get the underlying base type. TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); @@ -268,6 +271,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); + // For complex structs, the data param is the ABI struct pointer (e.g. BasicStruct*). // The Do_Abi parameter we receive is void* (per V3R3-M8), so the call-site needs an // explicit (T*) cast to bridge the type. For ref-types (string/runtime-class/object), @@ -447,6 +451,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string ptr = IdentifierEscaping.EscapeIdentifier(raw); TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); string rhs; + // String: HStringMarshaller.ConvertToUnmanaged if (underlying.IsString()) { @@ -523,6 +528,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); + // Determine the ABI element type for the data pointer cast (e.g. "void*" for // ref-like elements -> "void** data"/"(void**)", or "global::ABI.Foo.Bar" for // complex structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 9f4da9fc3..e059df8a9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -327,6 +327,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature sza = p.Type.AsSzArray()!; writer.WriteLine($"uint __{localName}_length = default;"); writer.WriteLine(); + // Element ABI type: void* for ref types; ABI struct for complex/blittable structs; // primitive ABI otherwise. string elemAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, sza.BaseType); @@ -622,6 +623,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.WriteLine("{"); fixedNesting++; writer.IncreaseIndent(); + // Inside the body: emit HStringMarshaller calls for input string params. for (int i = 0; i < sig.Parameters.Count; i++) { @@ -707,6 +709,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); + // For mapped value types (DateTime/TimeSpan) and complex structs, the storage // element is the ABI struct type; the data pointer parameter type uses that // ABI struct. The fixed() opens with void* (per truth's pattern), so a cast @@ -898,6 +901,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); ArrayTempNames names = new(localName); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szFA.BaseType)); + // Determine the ABI element type for the data pointer parameter (e.g. "void*" for // ref-like elements -> "void** data"/"(void**)", or "global::ABI.Foo.Bar" for complex // structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). @@ -991,6 +995,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sza.BaseType)); + // Element ABI type for the `data` parameter (void* for ref types, ABI struct for // complex structs, blittable struct ABI for blittable structs, primitive ABI otherwise). string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); @@ -1301,6 +1306,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); SzArrayTypeSignature sza = p.Type.AsSzArray()!; + // Element ABI type: same dispatch as the ConvertToManaged_ path. string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); @@ -1354,6 +1360,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec internal static void EmitParamArgConversion(IndentedTextWriter writer, ProjectionEmitContext context, ParameterInfo p, string? paramNameOverride = null) { string pname = paramNameOverride ?? p.GetRawName(); + // bool: ABI is 'bool' directly; pass as-is. if (p.Type is CorLibTypeSignature corlib && corlib.ElementType == ElementType.Boolean) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index d421ad3a9..7e3dca966 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -313,6 +313,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection // Per-property accessor state (origin tracking for getter/setter) Dictionary properties = []; + // Track the static factory ifaces we've emitted objref fields for (to dedupe) HashSet emittedObjRefs = []; @@ -331,6 +332,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection // Compute the objref name for this static factory interface. string objRef = ObjRefNameGenerator.GetObjRefName(context, staticIface); + // Compute the ABI Methods static class name (e.g. "global::ABI.Windows.System.ILauncherStaticsMethods") string abiClass = TypedefNameWriter.WriteTypedefName(context, staticIface, TypedefNameType.StaticAbiClass, true).Format(); @@ -434,6 +436,7 @@ public static event {{eventType}} {{evtName}} { StaticPropertyAccessorState s = kv.Value; writer.WriteLine(); + // when getter and setter platforms match; otherwise emit per-accessor. string getterPlat = s.GetterPlatformAttribute; string setterPlat = s.SetterPlatformAttribute; @@ -450,6 +453,7 @@ public static event {{eventType}} {{evtName}} writer.WriteIf(!string.IsNullOrEmpty(propertyPlat), propertyPlat); writer.Write($"public static {s.PropTypeText} {kv.Key}"); + // Getter-only -> expression body; otherwise -> accessor block (matches truth). // In ref mode, all accessor bodies emit '=> throw null;' bool getterOnly = s.HasGetter && !s.HasSetter; @@ -573,6 +577,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); + // are emitted as plain (non-partial) classes. string modifiers = TypeCategorization.IsStatic(type) ? "static " : type.IsSealed ? "sealed " : ""; WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index 313262966..18854268f 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -20,12 +20,14 @@ internal static partial class ClassMembersFactory public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { HashSet writtenMethods = []; + // For properties: track per-name accessor presence so we can merge get/set across interfaces. // Use insertion-order Dictionary so the per-class property emission order matches the // .winmd metadata definition order order). Dictionary propertyState = []; HashSet writtenEvents = []; HashSet writtenInterfaces = []; + // interface inside WriteInterfaceMembersRecursive (right before that interface's // members), instead of one upfront block. This interleaves the GetInterface() impls // with their corresponding interface body, matching truth's per-interface layout. @@ -35,6 +37,7 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo foreach (KeyValuePair kvp in propertyState) { PropertyAccessorState s = kvp.Value; + // For generic-interface properties, emit the UnsafeAccessor static externs above the // property declaration. Note: getter and setter use the same accessor name (because // C# allows method overloading on parameter list for the static externs). @@ -57,10 +60,12 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo } writer.WriteLine(); + // when getter and setter platforms match; otherwise emit per-accessor. string getterPlat = s.GetterPlatformAttribute; string setterPlat = s.SetterPlatformAttribute; string propertyPlat = string.Empty; + // If both accessor platform attributes are equal, collapse them to a single // property-level attribute. For getter-only or setter-only properties only one side // is set; compare the relevant side. @@ -77,6 +82,7 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo writer.WriteIf(!string.IsNullOrEmpty(propertyPlat), propertyPlat); writer.Write($"{s.Access}{s.MethodSpec}{s.PropTypeText} {kvp.Key}"); + // For getter-only properties, emit expression body: 'public T Prop => Expr;' // For getter+setter or setter-only, use accessor block: 'public T Prop { get => ...; set => ...; }' // In ref mode, all property bodies emit '=> throw null;' diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index e2a9b81ef..afb640ae3 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -170,6 +170,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE HashSet writtenMethods, IDictionary propertyState, HashSet writtenEvents) { bool sealed_ = classType.IsSealed; + // Determine accessibility and method modifier. // Overridable interfaces are emitted with 'protected' visibility, plus 'virtual' on // non-sealed classes. Sealed classes still get 'protected' (without virtual). @@ -251,6 +252,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE foreach (MethodDefinition method in ifaceType.GetNonSpecialMethods()) { string name = method.GetRawName(); + // Track by full signature (name + each param's element-type code) to avoid trivial overload duplicates. // This prevents collapsing distinct overloads like Format(double) and Format(ulong). MethodSignatureInfo sig = new(method, genericContext); @@ -519,6 +521,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // Emit the public/protected event with Subscribe/Unsubscribe. writer.WriteLine(); + // string to each event emission. In ref mode this produces e.g. // [global::System.Runtime.Versioning.SupportedOSPlatform("Windows10.0.16299.0")]. writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 2142e43c4..655883f45 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -75,6 +75,7 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo foreach (TypeDefinition iface in factoryInterfaces) { writer.Write(", "); + // CCW + non-forced namespace is the user-facing interface name (e.g. 'IButtonUtilsStatic'). TypedefNameWriter.WriteTypedefName(writer, context, iface, TypedefNameType.CCW, false); TypedefNameWriter.WriteTypeParams(writer, iface); @@ -340,6 +341,7 @@ public static class ManagedExports switch (activatableClassId) { """); + // Sort by the type's metadata token / row index so cases appear in WinMD declaration order. List orderedTypes = [.. kv.Value]; orderedTypes.Sort((a, b) => diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 1214a7c71..29e32b0ea 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -102,6 +102,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio string defaultIfaceIid = GetDefaultInterfaceIid(context, classType); string marshalingType = GetMarshalingTypeName(classType); + // Compute the platform attribute string from the activation factory interface's // [ContractVersion] attribute string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, factoryType); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 1642deeb1..8c0cf1f92 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -42,6 +42,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec ITypeDefOrRef? defaultIface = classType.GetDefaultInterface(); defaultIfaceObjRef = defaultIface is not null ? ObjRefNameGenerator.GetObjRefName(context, defaultIface) : string.Empty; int gcPressure = ClassFactory.GetGcPressureAmount(classType); + // Compute the platform attribute string from the composable factory interface's // [ContractVersion] attribute string platformAttribute = CustomAttributeFactory.GetPlatformAttribute(context, composableType); @@ -61,6 +62,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec // For the constructor on the projected class, we exclude the trailing two params. MethodSignatureInfo sig = new(method); int userParamCount = sig.Parameters.Count >= 2 ? sig.Parameters.Count - 2 : sig.Parameters.Count; + // the callback / args type name suffix is the TOTAL ABI param count // (size(method.Signature().Parameters())), NOT the user-visible param count. Using the // total count guarantees uniqueness against other composable factory overloads that diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index 8dbb058a1..4f7c98d22 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -138,6 +138,7 @@ private static string FormatCustomAttributeArg(CustomAttributeArgument arg) float f => f.ToString("R", CultureInfo.InvariantCulture) + "f", double d => d.ToString("R", CultureInfo.InvariantCulture), char c => "'" + c + "'", + // Always prepend 'global::' to typeof() arguments: when the generated file's namespace // context happens to contain a 'Windows' sub-namespace (e.g. 'TestComponentCSharp.Windows.*'), // an unqualified 'Windows.Foundation.X' would resolve to 'TestComponentCSharp.Windows.Foundation.X' diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index 6f9457084..4fea935ee 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -55,6 +55,7 @@ internal static void EmitEventTableField(IndentedTextWriter writer, ProjectionEm internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmitContext context, EventDefinition evt, MethodSignatureInfo sig, string ifaceFullName) { string evName = evt.Name?.Value ?? "Event"; + // Handler is the (last) input parameter of the add method. The emitted parameter name in the // signature comes from WriteAbiParameterTypesPointer which uses the metadata name verbatim. string handlerRawName = sig.Parameters.Count > 0 ? (sig.Parameters[^1].Parameter.Name ?? "handler") : "handler"; diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 03f2837b6..6a4ed90cb 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -63,6 +63,7 @@ public static void WriteTypeInheritance(IndentedTextWriter writer, ProjectionEmi if (hasNonObjectBase) { writer.Write(delimiter); + // Same-namespace types stay unqualified (e.g. 'AppointmentActionEntity : ActionEntity'): // only emit 'global::' when the base class lives in a different namespace. ITypeDefOrRef baseType = type.BaseType!; @@ -221,6 +222,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro foreach (MethodDefinition method in type.GetNonSpecialMethods()) { MethodSignatureInfo sig = new(method); + // Only emit Windows.Foundation.Metadata attributes that have a projected form // (Overload, DefaultOverload, AttributeUsage, Experimental). WriteMethodCustomAttributes(writer, method); @@ -232,6 +234,7 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro foreach (PropertyDefinition prop in type.Properties) { (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); + // Add 'new' when this interface has a setter-only property AND a property of the same // name exists on a base interface (typically the getter-only counterpart). This hides // the inherited member. @@ -350,6 +353,7 @@ private static void WriteMethodCustomAttributes(IndentedTextWriter writer, Metho } writer.Write($"[global::Windows.Foundation.Metadata.{baseName}"); + // Args: only handle string args (sufficient for [Overload(@"X")]). [DefaultOverload] has none. if (attr.Signature is not null && attr.Signature.FixedArguments.Count > 0) { diff --git a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs index 98c1e8374..9f10aea45 100644 --- a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs @@ -182,11 +182,13 @@ private static void EmitDictionary(IndentedTextWriter writer, ProjectionEmitCont string k = WriteTypeNameToString(context, args[0], TypedefNameType.Projected, true); string v = WriteTypeNameToString(context, args[1], TypedefNameType.Projected, true); + // Truth uses two forms for KeyValuePair: // - 'kv' (unqualified) for plain type usages: parameters, field/return types // - 'kvNested' (fully qualified) for generic argument usages (inside IEnumerator<>, ICollection<>) string kv = $"KeyValuePair<{k}, {v}>"; string kvNested = $"global::System.Collections.Generic.KeyValuePair<{k}, {v}>"; + // Long form (always fully qualified) used for objref field-name computation // (matches the form WriteClassObjRefDefinitions emits transitively). string kvLong = kvNested; @@ -196,6 +198,7 @@ private static void EmitDictionary(IndentedTextWriter writer, ProjectionEmitCont string valInteropArg = InteropTypeNameWriter.EncodeInteropTypeName(argSigs[1], TypedefNameType.Projected); string interopType = "ABI.System.Collections.Generic.<#corlib>IDictionary'2<" + keyInteropArg + "|" + valInteropArg + ">Methods, WinRT.Interop"; string prefix = "IDictionaryMethods_" + keyId + "_" + valId + "_"; + // The IEnumerable> objref name (matches what WriteClassObjRefDefinitions emits transitively). string enumerableObjRefName = "_objRef_System_Collections_Generic_IEnumerable_" + IidExpressionGenerator.EscapeTypeNameForIdentifier(kvLong, stripGlobal: false) + "_"; @@ -429,6 +432,7 @@ public object this[int index] public void RemoveAt(int index) => global::ABI.System.Collections.IListMethods.RemoveAt({{objRefName}}, index); public void CopyTo(Array array, int index) => global::ABI.System.Collections.IListMethods.CopyTo({{objRefName}}, array, index); """); + // GetEnumerator is NOT emitted here -- it's handled separately by IBindableIterable's // EmitNonGenericEnumerable invocation. } diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 8c833ff7f..d2215f47a 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -41,13 +41,16 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P { string nameStripped = type.GetStrippedName(); TypeCategory cat = TypeCategorization.GetCategory(type); + // "Almost-blittable" includes blittable + bool/char fields. Excludes string/object fields. // Use the same predicate as IsAnyStruct (which is now scoped to almost-blittable). TypeDefOrRefSignature sig = type.ToTypeSignature(false) is TypeDefOrRefSignature td2 ? td2 : null!; bool almostBlittable = cat == TypeCategory.Struct && (sig is null || context.AbiTypeShapeResolver.IsBlittableStruct(sig)); bool isEnum = cat == TypeCategory.Enum; + // Complex structs are non-almost-blittable structs with reference fields (string, object, etc.). bool isComplexStruct = cat == TypeCategory.Struct && !almostBlittable; + // Detect Nullable reference fields to determine whether the struct's BoxToUnmanaged // call needs CreateComInterfaceFlags.TrackerSupport . bool hasReferenceFields = false; @@ -140,6 +143,7 @@ public static unsafe class {{nameStripped}}Marshaller writer.Write($"value.{fname}"); } } + // - In component mode: emit object initializer with named field assignments // (positional ctor not always available on authored types). // - In non-component mode: emit positional constructor (matches the auto-generated @@ -333,6 +337,7 @@ file static class {{nameStripped}}InterfaceEntriesImpl } """); writer.WriteLine(); + // is NOT emitted for STRUCTS (the attribute is supplied by cswinrtgen instead). Enums // and other types still emit it from write_abi_enum/etc. if (context.Settings.Component && cat == TypeCategory.Struct) diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs index 930f017d0..5f16cc230 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs @@ -65,6 +65,7 @@ internal void WriteGeneratedInterfaceIidsFile() IndentedTextWriter guidIndented = guidIndentedOwner.Writer; IidExpressionGenerator.WriteInterfaceIidsBegin(guidIndented); guidIndented.IncreaseIndent(); + // Iterate namespaces in sorted order. Within each namespace, types are already sorted by SortMembersByName. // The sorted-by-namespace order produces the parent-before-child grouping in the // GeneratedInterfaceIIDs.cs output (e.g. Windows.ApplicationModel.* types before diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index 28d207ac1..0ba5a2b96 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -115,6 +115,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe } (string ns2, string nm2) = type.Names(); + // Skip generic types and mapped types if (MappedTypes.Get(ns2, nm2) is not null || TypeCategorization.IsGeneric(type)) { diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index e183b6a4b..af0b02694 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -142,6 +142,7 @@ public static string GetAbiStructTypeName(ProjectionEmitContext context, TypeSig { string ns = td.Type?.Namespace?.Value ?? string.Empty; string name = td.Type?.Name?.Value ?? string.Empty; + // If this struct is mapped, use the mapped namespace+name (e.g. // 'Windows.UI.Xaml.Interop.TypeName' is mapped to 'System.Type', so the ABI struct // is 'global::ABI.System.Type', not 'global::ABI.Windows.UI.Xaml.Interop.TypeName'). @@ -191,6 +192,7 @@ public static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature sig) private static string GetProjectedEnumName(TypeDefinition def) { (string ns, string name) = def.Names(); + // Apply mapped-type translation so consumers see the projected (.NET) enum name // (e.g. Windows.UI.Xaml.Interop.NotifyCollectionChangedAction → // System.Collections.Specialized.NotifyCollectionChangedAction). Same diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index ffa0e59fd..1ef2ec6df 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -81,6 +81,7 @@ internal static bool IsFieldTypeBlittable(MetadataCache cache, TypeSignature sig { string fNs = todr.Type?.Namespace?.Value ?? string.Empty; string fName = todr.Type?.Name?.Value ?? string.Empty; + // System.Guid is a fundamental blittable type . // Same applies to System.IntPtr / UIntPtr (used in some struct layouts). if (fNs == "System" && (fName is "Guid" or "IntPtr" || fName == "UIntPtr")) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.MappedTypes.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.MappedTypes.cs index eca5c68e7..e23050360 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.MappedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.MappedTypes.cs @@ -68,6 +68,7 @@ private static bool IsMappedMarshalingValueType(TypeSignature sig, out string ma } (string ns, string name) = td.Names(); + // The set of mapped types that use the 'value-type marshaller' pattern (DateTime, TimeSpan, HResult). // Uri is also a mapped marshalling type but it's a reference type (handled via UriMarshaller separately). if (ns == WindowsFoundation) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs index 5b4f7d0cb..ad216fc3b 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs @@ -29,6 +29,7 @@ internal static bool TryGetNullablePrimitiveMarshallerName(TypeSignature sig, ou ITypeDefOrRef gt = gi.GenericType; string ns = gt?.Namespace?.Value ?? string.Empty; string name = gt?.Name?.Value ?? string.Empty; + // In WinMD metadata, Nullable is encoded as Windows.Foundation.IReference. // It only later gets projected to System.Nullable by the projection layer. bool isNullable = (ns == "System" && name == NullableGeneric) @@ -45,6 +46,7 @@ internal static bool TryGetNullablePrimitiveMarshallerName(TypeSignature sig, ou } TypeSignature arg = gi.TypeArguments[0]; + // Map primitive corlib element type to its ABI marshaller name. if (arg is CorLibTypeSignature corlib) { @@ -141,6 +143,7 @@ internal static string GetMarshallerFullName(IndentedTextWriter writer, Projecti { string ns = td.Type?.Namespace?.Value ?? string.Empty; string name = td.Type?.Name?.Value ?? string.Empty; + // Apply mapped type remapping (e.g. System.Uri -> Windows.Foundation.Uri) _ = MappedTypes.ApplyMapping(ref ns, ref name); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 25bdeec2f..5fa86348c 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -48,6 +48,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext else if (TypeCategorization.GetCategory(d.Type) is TypeCategory.Struct) { (string dNs, string dName) = d.Type.Names(); + // Special case: mapped value types that require ABI marshalling // (DateTime/TimeSpan -> ABI.System.DateTimeOffset/TimeSpan). if (dNs == WindowsFoundation && dName == "DateTime") @@ -77,6 +78,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext } TypeSignature dts = d.Type.ToTypeSignature(); + // "Almost-blittable" structs (with bool/char fields but no reference-type // fields) can pass through using the projected type since the C# layout // matches the WinRT ABI directly. Truly complex structs (with string/object/ @@ -97,11 +99,13 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext break; case TypeSemantics.Reference r: + // Cross-module typeref: try resolving the type, applying mapped-type translation // for the field/parameter type after resolution. if (context.Cache is not null) { (string rns, string rname) = r.Type.Names(); + // Special case: mapped value types that require ABI marshalling. if (rns == WindowsFoundation && rname == "DateTime") { @@ -123,6 +127,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext // Look up the type by its ORIGINAL (unmapped) name in the cache. TypeDefinition? rd = context.Cache.Find(rns, rname); + // If not found, try the mapped name (for cases where the mapping target is in the cache). if (rd is null) { diff --git a/src/WinRT.Projection.Writer/Helpers/ArrayElementEncoder.cs b/src/WinRT.Projection.Writer/Helpers/ArrayElementEncoder.cs index 549823141..8beafbe40 100644 --- a/src/WinRT.Projection.Writer/Helpers/ArrayElementEncoder.cs +++ b/src/WinRT.Projection.Writer/Helpers/ArrayElementEncoder.cs @@ -26,6 +26,7 @@ internal static string GetArrayMarshallerInteropPath(TypeSignature elementType) // but inside the array brackets the interop generator uses the depth=0 form (assembly + just name). // Re-encode the element with the top-level form for accurate matching. string topLevelElement = EncodeArrayElementName(elementType); + // Resolve the element's namespace to determine the path prefix. string ns = AbiTypeHelpers.GetMappedNamespace(elementType); @@ -82,6 +83,7 @@ private static void EncodeArrayElementNameInto(System.Text.StringBuilder sb, Typ private static void EncodeArrayElementForTypeDef(StringBuilder sb, ITypeDefOrRef type, IList? generic_args) { (string typeNs, string typeName) = type.Names(); + // Apply mapped-type remapping (e.g. Windows.Foundation.IReference -> System.Nullable). MappedType? mapped = MappedTypes.Get(typeNs, typeName); @@ -98,6 +100,7 @@ private static void EncodeArrayElementForTypeDef(StringBuilder sb, ITypeDefOrRef // types resolve to their actual assembly name (e.g. ) instead of // defaulting to <#Windows>. _ = sb.Append(InteropTypeNameWriter.GetInteropAssemblyMarker(typeNs, typeName, mapped, type)); + // Top-level: just the type name (no namespace). _ = sb.Append(typeName); diff --git a/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs b/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs index 0c1529cdc..620aaba7d 100644 --- a/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs @@ -97,6 +97,7 @@ public static IEnumerable> Get(TypeDefiniti for (int i = 0; i < attr.Signature.FixedArguments.Count; i++) { CustomAttributeArgument arg = attr.Signature.FixedArguments[i]; + // For System.Type args in WinMD, the value is typically a TypeSignature if (arg.Element is TypeSignature sig) { diff --git a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs index e03b2f009..6424cfbbe 100644 --- a/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/IidExpressionGenerator.cs @@ -69,6 +69,7 @@ private static void WriteGuid(IndentedTextWriter writer, Guid guid, bool lowerCa ushort data3 = (ushort)(bytes[6] | (bytes[7] << 8)); string fmt = lowerCase ? "x" : "X"; + // Format: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x writer.Write($"{data1.ToString(fmt + "8", CultureInfo.InvariantCulture)}-{data2.ToString(fmt + "4", CultureInfo.InvariantCulture)}-{data3.ToString(fmt + "4", CultureInfo.InvariantCulture)}-"); @@ -297,6 +298,7 @@ public static void WriteIidGuidPropertyForClassInterfaces(IndentedTextWriter wri } (string ns, string nm) = ifaceType.Names(); + // Skip mapped types if (MappedTypes.Get(ns, nm) is not null) { diff --git a/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs index f87940611..efa8058da 100644 --- a/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/InteropTypeNameWriter.cs @@ -155,6 +155,7 @@ private static void EncodeForTypeDef(StringBuilder sb, ITypeDefOrRef type, Typed _ = sb.Append("WindowsRuntime.InteropServices.<#CsWinRT>EventHandlerEventSource'"); _ = sb.Append(arity.ToString(CultureInfo.InvariantCulture)); + // Append the generic args (if any). if (generic_args is { Count: > 0 }) { diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 248675ef8..888935fb6 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -387,6 +387,7 @@ private static void EmitObjRefForInterface(IndentedTextWriter writer, Projection { // Sealed-class default interface: simple expression-bodied property pointing at NativeObjectReference. writer.WriteLine($"private WindowsRuntimeObjectReference {objRefName} => NativeObjectReference;"); + // Emit the unsafe accessor AFTER the field so it can be used to pass the IID in the // constructor for the default interface. if (gi is not null) diff --git a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs index 1857544bf..971a2c02e 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs @@ -230,6 +230,7 @@ private static TypeSemantics GetCorLib(ElementType elementType) private static TypeSemantics GetGenericInstance(GenericInstanceTypeSignature gi) { ITypeDefOrRef genericType = gi.GenericType; + // Always preserve the type arguments. List args = new(gi.TypeArguments.Count); foreach (TypeSignature arg in gi.TypeArguments) From 8f6496136d98c9b18a02f440a6775c6a23151086 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Tue, 19 May 2026 23:54:33 -0700 Subject: [PATCH 126/171] Move registry error comment into catch block Relocate the explanatory comment about registry view failures into the catch block handling IOException/UnauthorizedAccessException/SecurityException and tidy up surrounding whitespace. This is a purely cosmetic/refactoring change to improve clarity; no functional behavior was altered. --- .../Helpers/WindowsMetadataExpander.cs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/WindowsMetadataExpander.cs b/src/WinRT.Projection.Writer/Helpers/WindowsMetadataExpander.cs index 71269a79e..8f7cb1a76 100644 --- a/src/WinRT.Projection.Writer/Helpers/WindowsMetadataExpander.cs +++ b/src/WinRT.Projection.Writer/Helpers/WindowsMetadataExpander.cs @@ -145,15 +145,16 @@ private static string TryGetSdkPath() return p2; } } - - // Both views can fail with permission errors on hardened machines, or with I/O errors - // when the registry hive is being modified concurrently by an installer. Treat any of - // those as "no SDK detected" and let the caller fall back to the path-not-found error. catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or SecurityException) { + // Both views can fail with permission errors on hardened machines, or with I/O errors + // when the registry hive is being modified concurrently by an installer. Treat any of + // those as "no SDK detected" and let the caller fall back to the path-not-found error. } + return string.Empty; } + private static string TryGetCurrentSdkVersion() { string sdkPath = TryGetSdkPath(); From 17cea95899f657d6bdf1339647040e65068b186a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:02:17 -0700 Subject: [PATCH 127/171] Unify ITypeDefOrRef extensions M5: Move GetStrippedName() into the canonical Extensions/ITypeDefOrRefExtensions.cs as an extension(ITypeDefOrRef) member alongside the other ITypeDefOrRef extensions, and delete the orphan Helpers/TypeDefOrRefExtensions.cs. This eliminates the dual-location pattern that was a discoverability problem for callers and the upstream cause of inline StripBackticks(type.Name?.Value ?? string.Empty) duplication (addressed separately). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ITypeDefOrRefExtensions.cs | 12 ++++++++++ .../Helpers/TypeDefOrRefExtensions.cs | 24 ------------------- 2 files changed, 12 insertions(+), 24 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index de85eee75..4b6dbd45c 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -4,6 +4,7 @@ using System.Diagnostics.CodeAnalysis; using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; namespace WindowsRuntime.ProjectionWriter; @@ -15,6 +16,17 @@ internal static class ITypeDefOrRefExtensions { extension(ITypeDefOrRef type) { + /// + /// Returns the type's metadata name with any generic-arity backtick suffix stripped + /// (e.g. "IList`1" becomes "IList"). When the type has no name, returns + /// . + /// + /// The type's stripped name. + public string GetStrippedName() + { + return IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); + } + /// /// Attempts to resolve against , returning /// when the type cannot be resolved (missing assembly, invalid reference, diff --git a/src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs deleted file mode 100644 index 45bfbaa53..000000000 --- a/src/WinRT.Projection.Writer/Helpers/TypeDefOrRefExtensions.cs +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using AsmResolver.DotNet; - -namespace WindowsRuntime.ProjectionWriter.Helpers; - -/// -/// Extension methods on and related metadata types. -/// -internal static class TypeDefOrRefExtensions -{ - /// - /// Returns the type's metadata name with any generic-arity backtick suffix stripped - /// (e.g. "IList`1" becomes "IList"). When the type has no name, returns - /// . - /// - /// The type to derive the stripped name from. - /// The type's stripped name. - public static string GetStrippedName(this ITypeDefOrRef type) - { - return IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); - } -} From 69320b6ae6dc6a6bd6715210cc125fd464c2cf34 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:03:00 -0700 Subject: [PATCH 128/171] Replace ClassFactory.InterfacesEqual with AbiTypeHelpers.InterfacesEqualByName M9: ClassFactory.InterfacesEqual was a character-for-character copy of AbiTypeHelpers.InterfacesEqualByName. Replace the three call sites with the public helper and delete the private duplicate. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ClassFactory.cs | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 7e3dca966..bfaf4f760 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -103,14 +103,14 @@ public static bool IsFastAbiOtherInterface(MetadataCache cache, TypeDefinition i return false; } - if (fastAbi.Value.Default is not null && InterfacesEqual(fastAbi.Value.Default, iface)) + if (fastAbi.Value.Default is not null && AbiTypeHelpers.InterfacesEqualByName(fastAbi.Value.Default, iface)) { return false; } foreach (TypeDefinition other in fastAbi.Value.Others) { - if (InterfacesEqual(other, iface)) + if (AbiTypeHelpers.InterfacesEqualByName(other, iface)) { return true; } @@ -130,18 +130,7 @@ public static bool IsFastAbiDefaultInterface(MetadataCache cache, TypeDefinition return false; } - return fastAbi.Value.Default is not null && InterfacesEqual(fastAbi.Value.Default, iface); - } - - private static bool InterfacesEqual(TypeDefinition a, TypeDefinition b) - { - if (a == b) - { - return true; - } - - return (a.Namespace?.Value ?? string.Empty) == (b.Namespace?.Value ?? string.Empty) - && (a.Name?.Value ?? string.Empty) == (b.Name?.Value ?? string.Empty); + return fastAbi.Value.Default is not null && AbiTypeHelpers.InterfacesEqualByName(fastAbi.Value.Default, iface); } // We don't have direct access to the active Settings from a static helper that only takes From acd0042efdbe3a6774c3fd8dd42480ceff82cb87 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:04:03 -0700 Subject: [PATCH 129/171] Inline well-known interface entries into delegate emitter M10: Delete the WellKnownInterfaceEntriesEmitter helper and fold its 14 IID/Vtable initializer lines back into the single multiline raw string in AbiDelegateFactory.WriteDelegateReferenceInterfaceEntries. Readability over de-duplication here -- the only consumer was this one site, and the surrounding indent gymnastics (IncreaseIndent x2 / DecreaseIndent x2 wrapping a helper call) added more cognitive load than the inlined block does. The other site noted in the duplication report (StructEnumMarshallerFactory) was never wired through the helper -- it had its own inline copy. Each emitter now owns its own clearly-readable block. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiDelegateFactory.cs | 21 ++++++---- .../WellKnownInterfaceEntriesEmitter.cs | 39 ------------------- 2 files changed, 14 insertions(+), 46 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 90c7e00b0..c0606ce59 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -202,13 +202,20 @@ file static class {{nameStripped}}InterfaceEntriesImpl Entries.Delegate.Vtable = {{nameStripped}}Impl.Vtable; Entries.DelegateReference.IID = {{iidRefExpr}}; Entries.DelegateReference.Vtable = {{nameStripped}}ReferenceImpl.Vtable; - """); - writer.IncreaseIndent(); - writer.IncreaseIndent(); - WellKnownInterfaceEntriesEmitter.EmitDelegateReferenceWellKnownEntries(writer); - writer.DecreaseIndent(); - writer.DecreaseIndent(); - writer.WriteLine(isMultiline: true, """ + Entries.IPropertyValue.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IPropertyValue; + Entries.IPropertyValue.Vtable = global::WindowsRuntime.InteropServices.IPropertyValueImpl.OtherTypeVtable; + Entries.IStringable.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IStringable; + Entries.IStringable.Vtable = global::WindowsRuntime.InteropServices.IStringableImpl.Vtable; + Entries.IWeakReferenceSource.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IWeakReferenceSource; + Entries.IWeakReferenceSource.Vtable = global::WindowsRuntime.InteropServices.IWeakReferenceSourceImpl.Vtable; + Entries.IMarshal.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IMarshal; + Entries.IMarshal.Vtable = global::WindowsRuntime.InteropServices.IMarshalImpl.Vtable; + Entries.IAgileObject.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IAgileObject; + Entries.IAgileObject.Vtable = global::WindowsRuntime.InteropServices.IAgileObjectImpl.Vtable; + Entries.IInspectable.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IInspectable; + Entries.IInspectable.Vtable = global::WindowsRuntime.InteropServices.IInspectableImpl.Vtable; + Entries.IUnknown.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IUnknown; + Entries.IUnknown.Vtable = global::WindowsRuntime.InteropServices.IUnknownImpl.Vtable; } } """); diff --git a/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs b/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs deleted file mode 100644 index 623b6a677..000000000 --- a/src/WinRT.Projection.Writer/Helpers/WellKnownInterfaceEntriesEmitter.cs +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using WindowsRuntime.ProjectionWriter.Writers; - -namespace WindowsRuntime.ProjectionWriter.Helpers; - -/// -/// Emits the IID/Vtable initializer pairs for the well-known WinRT interfaces (IPropertyValue, -/// IStringable, IWeakReferenceSource, IMarshal, IAgileObject, IInspectable, IUnknown) that -/// every CCW interface-entries struct exposes. -/// -internal static class WellKnownInterfaceEntriesEmitter -{ - /// - /// Emits the well-known interface entries for a delegate's reference interface entries. - /// Lines are written in the order expected by DelegateReferenceInterfaceEntries. - /// - /// The writer to emit to. - public static void EmitDelegateReferenceWellKnownEntries(IndentedTextWriter writer) - { - writer.WriteLine(isMultiline: true, """ - Entries.IPropertyValue.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IPropertyValue; - Entries.IPropertyValue.Vtable = global::WindowsRuntime.InteropServices.IPropertyValueImpl.OtherTypeVtable; - Entries.IStringable.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IStringable; - Entries.IStringable.Vtable = global::WindowsRuntime.InteropServices.IStringableImpl.Vtable; - Entries.IWeakReferenceSource.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IWeakReferenceSource; - Entries.IWeakReferenceSource.Vtable = global::WindowsRuntime.InteropServices.IWeakReferenceSourceImpl.Vtable; - Entries.IMarshal.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IMarshal; - Entries.IMarshal.Vtable = global::WindowsRuntime.InteropServices.IMarshalImpl.Vtable; - Entries.IAgileObject.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IAgileObject; - Entries.IAgileObject.Vtable = global::WindowsRuntime.InteropServices.IAgileObjectImpl.Vtable; - Entries.IInspectable.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IInspectable; - Entries.IInspectable.Vtable = global::WindowsRuntime.InteropServices.IInspectableImpl.Vtable; - Entries.IUnknown.IID = global::WindowsRuntime.InteropServices.WellKnownInterfaceIIDs.IID_IUnknown; - Entries.IUnknown.Vtable = global::WindowsRuntime.InteropServices.IUnknownImpl.Vtable; - """); - } -} From 92a587cc47d35728cfbf23686d66808764b144d8 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:06:42 -0700 Subject: [PATCH 130/171] Consolidate attribute lookup on IHasCustomAttribute extensions M1: Add CountAttributes(ns, name) to IHasCustomAttributeExtensions alongside the existing HasAttribute/GetAttribute. Replace duplicate implementations: - TypeCategorization.HasAttribute / GetAttribute (deleted; internal calls rewired to the extension). - ClassFactory.CountAttributes private helper (deleted; two call sites use the extension directly). - ConstructorFactory.GetMarshalingTypeName rewritten on top of GetAttribute(WindowsFoundationMetadata, `MarshalingBehaviorAttribute`) -- no behavioral change. AttributedTypes.Get and AbiTypeHelpers.GetExclusiveToType (both also flagged by M1) are addressed by the M14 simplification below. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../IHasCustomAttributeExtensions.cs | 22 ++++++++++ .../Factories/ClassFactory.cs | 19 +------- .../Factories/ConstructorFactory.cs | 44 +++++++------------ .../Metadata/TypeCategorization.cs | 44 ++----------------- 4 files changed, 43 insertions(+), 86 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs b/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs index b8e502e6a..1e7f310f0 100644 --- a/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/IHasCustomAttributeExtensions.cs @@ -53,6 +53,28 @@ public bool HasAttribute(string ns, string name) return null; } + /// + /// Returns the number of custom attributes on the member matching the given + /// and . + /// + /// The namespace of the attribute type. + /// The unqualified type name of the attribute. + /// The number of matching custom attributes. + public int CountAttributes(string ns, string name) + { + int count = 0; + + foreach (CustomAttribute attribute in member.CustomAttributes) + { + if (attribute.Type?.IsTypeOf(ns, name) is true) + { + count++; + } + } + + return count; + } + /// /// Convenience for HasAttribute(ns, name) with the namespace fixed to /// Windows.Foundation.Metadata. diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index bfaf4f760..1de49c54f 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -176,8 +176,8 @@ public static (TypeDefinition? DefaultInterface, System.Collections.Generic.List // 4. Type namespace and name (ascending) exclusiveIfaces.Sort((a, b) => { - int aPrev = -CountAttributes(a, WindowsFoundationMetadata, "PreviousContractVersionAttribute"); - int bPrev = -CountAttributes(b, WindowsFoundationMetadata, "PreviousContractVersionAttribute"); + int aPrev = -a.CountAttributes(WindowsFoundationMetadata, "PreviousContractVersionAttribute"); + int bPrev = -b.CountAttributes(WindowsFoundationMetadata, "PreviousContractVersionAttribute"); if (aPrev != bPrev) { @@ -213,21 +213,6 @@ public static (TypeDefinition? DefaultInterface, System.Collections.Generic.List return (defaultIface, exclusiveIfaces); } - private static int CountAttributes(IHasCustomAttribute member, string ns, string name) - { - int count = 0; - for (int i = 0; i < member.CustomAttributes.Count; i++) - { - CustomAttribute attr = member.CustomAttributes[i]; - ITypeDefOrRef? type = attr.Constructor?.DeclaringType; - - if (type is not null && type.Namespace == ns && type.Name == name) - { - count++; - } - } - return count; - } /// /// Returns the GC-pressure cost (in bytes) declared by [GCPressureAttribute] on , or 0 if not annotated. /// diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.cs index 04b8906c7..4955ba0b4 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.cs @@ -27,42 +27,28 @@ internal static partial class ConstructorFactory /// internal static string GetMarshalingTypeName(TypeDefinition classType) { - for (int i = 0; i < classType.CustomAttributes.Count; i++) - { - CustomAttribute attr = classType.CustomAttributes[i]; - ITypeDefOrRef? attrType = attr.Constructor?.DeclaringType; - - if (attrType is null) - { - continue; - } + CustomAttribute? attr = classType.GetAttribute(WindowsFoundationMetadata, "MarshalingBehaviorAttribute"); - if (attrType.Namespace?.Value != WindowsFoundationMetadata || - attrType.Name?.Value != "MarshalingBehaviorAttribute") - { - continue; - } + if (attr is null || attr.Signature is null) + { + return "CreateObjectReferenceMarshalingType.Unknown"; + } - if (attr.Signature is null) - { - continue; - } + for (int j = 0; j < attr.Signature.FixedArguments.Count; j++) + { + CustomAttributeArgument arg = attr.Signature.FixedArguments[j]; - for (int j = 0; j < attr.Signature.FixedArguments.Count; j++) + if (arg.Element is int v) { - CustomAttributeArgument arg = attr.Signature.FixedArguments[j]; - - if (arg.Element is int v) + return v switch { - return v switch - { - 2 => "CreateObjectReferenceMarshalingType.Agile", - 3 => "CreateObjectReferenceMarshalingType.Standard", - _ => "CreateObjectReferenceMarshalingType.Unknown", - }; - } + 2 => "CreateObjectReferenceMarshalingType.Agile", + 3 => "CreateObjectReferenceMarshalingType.Standard", + _ => "CreateObjectReferenceMarshalingType.Unknown", + }; } } + return "CreateObjectReferenceMarshalingType.Unknown"; } } diff --git a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs index bd6ea5c02..3b4f4d660 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs @@ -95,7 +95,7 @@ public static bool IsAttributeType(TypeDefinition type) public static bool IsApiContractType(TypeDefinition type) { return GetCategory(type) == TypeCategory.Struct && - HasAttribute(type, WindowsFoundationMetadata, "ApiContractAttribute"); + type.HasAttribute(WindowsFoundationMetadata, "ApiContractAttribute"); } /// @@ -112,7 +112,7 @@ public static bool IsStatic(TypeDefinition type) public static bool IsExclusiveTo(TypeDefinition type) { return GetCategory(type) == TypeCategory.Interface && - HasAttribute(type, WindowsFoundationMetadata, ExclusiveToAttribute); + type.HasAttribute(WindowsFoundationMetadata, ExclusiveToAttribute); } /// @@ -121,7 +121,7 @@ public static bool IsExclusiveTo(TypeDefinition type) public static bool IsFlagsEnum(TypeDefinition type) { return GetCategory(type) == TypeCategory.Enum && - HasAttribute(type, "System", "FlagsAttribute"); + type.HasAttribute("System", "FlagsAttribute"); } /// @@ -137,42 +137,6 @@ public static bool IsGeneric(TypeDefinition type) /// public static bool IsProjectionInternal(TypeDefinition type) { - return HasAttribute(type, WindowsRuntimeInternal, "ProjectionInternalAttribute"); - } - - /// - /// True if this type's CustomAttributes contains the given attribute. - /// - public static bool HasAttribute(IHasCustomAttribute member, string ns, string name) - { - for (int i = 0; i < member.CustomAttributes.Count; i++) - { - CustomAttribute attr = member.CustomAttributes[i]; - ITypeDefOrRef? type = attr.Constructor?.DeclaringType; - - if (type is not null && type.Namespace == ns && type.Name == name) - { - return true; - } - } - return false; - } - - /// - /// Gets the matching CustomAttribute or null. - /// - public static CustomAttribute? GetAttribute(IHasCustomAttribute member, string ns, string name) - { - for (int i = 0; i < member.CustomAttributes.Count; i++) - { - CustomAttribute attr = member.CustomAttributes[i]; - ITypeDefOrRef? type = attr.Constructor?.DeclaringType; - - if (type is not null && type.Namespace == ns && type.Name == name) - { - return attr; - } - } - return null; + return type.HasAttribute(WindowsRuntimeInternal, "ProjectionInternalAttribute"); } } From 24ec564588b6e3281c2a7cebd2f1188599d26a73 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:07:58 -0700 Subject: [PATCH 131/171] Adopt GetStrippedName() at type-name strip sites M2: Replace 7 inline IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty) sites with the existing ype.GetStrippedName() extension (now living alongside the other ITypeDefOrRef extensions after M5). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs | 4 ++-- .../Factories/AbiInterfaceFactory.cs | 4 ++-- .../Factories/StructEnumMarshallerFactory.cs | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 775f2e4ae..98bd48fb5 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -48,7 +48,7 @@ public static void WriteAbiClass(IndentedTextWriter writer, ProjectionEmitContex /// internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string nameStripped = IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); + string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; string projectedType = $"global::{typeNs}.{nameStripped}"; @@ -114,7 +114,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedT /// internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string nameStripped = IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); + string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; string projectedType = string.IsNullOrEmpty(typeNs) ? $"global::{nameStripped}" : $"global::{typeNs}.{nameStripped}"; string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index b8413abb8..7408a3841 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -315,7 +315,7 @@ public static nint Vtable if (exclusiveToOwner is not null && !exclusiveIsFactoryOrStatic) { string ownerNs = exclusiveToOwner.Namespace?.Value ?? string.Empty; - string ownerNm = IdentifierEscaping.StripBackticks(exclusiveToOwner.Name?.Value ?? string.Empty); + string ownerNm = exclusiveToOwner.GetStrippedName(); ifaceFullName = string.IsNullOrEmpty(ownerNs) ? GlobalPrefix + ownerNm : GlobalPrefix + ownerNs + "." + ownerNm; @@ -325,7 +325,7 @@ public static nint Vtable // Factory/static interfaces in authoring mode are implemented by the generated // 'global::ABI.Impl..' type that the activation factory CCW exposes. string ifaceNs = type.Namespace?.Value ?? string.Empty; - string ifaceNm = IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); + string ifaceNm = type.GetStrippedName(); ifaceFullName = string.IsNullOrEmpty(ifaceNs) ? "global::ABI.Impl." + ifaceNm : "global::ABI.Impl." + ifaceNs + "." + ifaceNm; diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index d2215f47a..6ff45ab37 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -132,7 +132,7 @@ public static unsafe class {{nameStripped}}Marshaller && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd)) { // Nested non-blittable struct: marshal via its Marshaller. - writer.Write($"{IdentifierEscaping.StripBackticks(fieldStructTd.Name?.Value ?? string.Empty)}Marshaller.ConvertToUnmanaged(value.{fname})"); + writer.Write($"{fieldStructTd.GetStrippedName()}Marshaller.ConvertToUnmanaged(value.{fname})"); } else if (AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out string? nullableMarshaller)) { @@ -193,7 +193,7 @@ public static unsafe class {{nameStripped}}Marshaller && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd2)) { // Nested non-blittable struct: convert via its Marshaller. - writer.Write($"{IdentifierEscaping.StripBackticks(fieldStructTd2.Name?.Value ?? string.Empty)}Marshaller.ConvertToManaged(value.{fname})"); + writer.Write($"{fieldStructTd2.GetStrippedName()}Marshaller.ConvertToManaged(value.{fname})"); } else if (AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out string? nullableMarshaller)) { @@ -242,7 +242,7 @@ public static void Dispose({{abi}} value) { // Nested non-blittable struct: dispose via its Marshaller. string nestedNs = fieldStructTd3.Namespace?.Value ?? string.Empty; - string nestedNm = IdentifierEscaping.StripBackticks(fieldStructTd3.Name?.Value ?? string.Empty); + string nestedNm = fieldStructTd3.GetStrippedName(); writer.WriteLine($"global::ABI.{nestedNs}.{nestedNm}Marshaller.Dispose(value.{fname});"); } else if (AbiTypeHelpers.TryGetNullablePrimitiveMarshallerName(ft, out _)) From 2c3827b82828d0bb99728701b2fafb2a802321ab Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:10:38 -0700 Subject: [PATCH 132/171] Use ITypeDefOrRef.FullName and Names() at duplicate-form sites M18: - Replace 5 manual `(type.Namespace?.Value ?? string.Empty) + `.` + (type.Name?.Value ?? string.Empty)` concatenations with `type.FullName ?? string.Empty` (ClassFactory, ConstructorFactory.AttributedTypes x2, ConstructorFactory.Composable, ConstructorFactory.AttributedTypes No-factory branch). Same semantics, fewer characters, no special-case for empty namespace because AsmResolver already handles it. - Collapse the paired `ns/name = X.Namespace/Name?.Value ?? string.Empty` assignment in ObjRefNameGenerator.WriteIidExpression to `(ns, name) = X.Names()`. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/WinRT.Projection.Writer/Factories/ClassFactory.cs | 2 +- .../Factories/ConstructorFactory.AttributedTypes.cs | 6 +++--- .../Factories/ConstructorFactory.Composable.cs | 2 +- src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs | 6 ++---- 4 files changed, 7 insertions(+), 9 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 1de49c54f..bd9062817 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -291,7 +291,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection // Track the static factory ifaces we've emitted objref fields for (to dedupe) HashSet emittedObjRefs = []; - string runtimeClassFullName = (type.Namespace?.Value ?? string.Empty) + "." + (type.Name?.Value ?? string.Empty); + string runtimeClassFullName = type.FullName ?? string.Empty; foreach (KeyValuePair kv in AttributedTypes.Get(type, context.Cache)) { diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 29e32b0ea..4cf0bc833 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -41,7 +41,7 @@ public static void WriteAttributedTypes(IndentedTextWriter writer, ProjectionEmi if (needsClassObjRef) { - string fullName = (classType.Namespace?.Value ?? string.Empty) + "." + (classType.Name?.Value ?? string.Empty); + string fullName = classType.FullName ?? string.Empty; string objRefName = "_objRef_" + IidExpressionGenerator.EscapeTypeNameForIdentifier(GlobalPrefix + fullName, stripGlobal: true); writer.WriteLine(); writer.Write($"private static WindowsRuntimeObjectReference {objRefName}"); @@ -96,7 +96,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio if (factoryType is not null) { // Emit the factory objref property (lazy-initialized). - string factoryRuntimeClassFullName = (classType.Namespace?.Value ?? string.Empty) + "." + typeName; + string factoryRuntimeClassFullName = classType.FullName ?? string.Empty; string factoryObjRefName = ObjRefNameGenerator.GetObjRefName(context, factoryType); ClassFactory.WriteStaticFactoryObjRef(writer, context, factoryType, factoryRuntimeClassFullName, factoryObjRefName); @@ -173,7 +173,7 @@ public static void WriteFactoryConstructors(IndentedTextWriter writer, Projectio // No factory type means [Activatable(uint version)] - emit a default ctor that calls // the WindowsRuntimeObject base constructor with the activation factory objref. // The default interface IID is needed too. - string fullName = (classType.Namespace?.Value ?? string.Empty) + "." + typeName; + string fullName = classType.FullName ?? string.Empty; string objRefName = "_objRef_" + IidExpressionGenerator.EscapeTypeNameForIdentifier(GlobalPrefix + fullName, stripGlobal: true); // Find the default interface IID to use. diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 8c0cf1f92..7cda2c6fa 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -31,7 +31,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec // Emit the factory objref + IIDs at the top so the parameterized ctors can reference it. if (composableType.Methods.Count > 0) { - string runtimeClassFullName = (classType.Namespace?.Value ?? string.Empty) + "." + typeName; + string runtimeClassFullName = classType.FullName ?? string.Empty; string factoryObjRefName = ObjRefNameGenerator.GetObjRefName(context, composableType); ClassFactory.WriteStaticFactoryObjRef(writer, context, composableType, runtimeClassFullName, factoryObjRefName); } diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 888935fb6..4f7731761 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -150,14 +150,12 @@ public static void WriteIidExpression(IndentedTextWriter writer, ProjectionEmitC if (ifaceType is TypeDefinition td) { - ns = td.Namespace?.Value ?? string.Empty; - name = td.Name?.Value ?? string.Empty; + (ns, name) = td.Names(); isMapped = MappedTypes.IsMapped(ns, name); } else if (ifaceType is TypeReference tr) { - ns = tr.Namespace?.Value ?? string.Empty; - name = tr.Name?.Value ?? string.Empty; + (ns, name) = tr.Names(); isMapped = MappedTypes.IsMapped(ns, name); } else From 592330278c4848cabbbb7889ea6449513790da2e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:12:23 -0700 Subject: [PATCH 133/171] Move StripByRefAndCustomModifiers to TypeSignature extension M7: Convert AbiTypeHelpers.StripByRefAndCustomModifiers(TypeSignature) into a TypeSignature extension method, alongside the existing AsSzArray()/SzArrayElement() siblings. Rewrite the existing 2 helper callers (AsSzArray, SzArrayElement) plus all 17 external callers (Models, Resolvers, RcwCaller, DoAbi) to use sig.StripByRefAndCustomModifiers(). Delete the original AbiTypeHelpers static helper. Two using directives become unneeded as a side-effect (ParameterCategoryResolver and MethodSignatureMarshallingFacts no longer import WindowsRuntime.ProjectionWriter.Helpers solely for this one call). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeSignatureExtensions.cs | 33 +++++++++++++++++-- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 8 ++--- .../AbiMethodBodyFactory.RcwCaller.cs | 20 +++++------ .../Helpers/AbiTypeHelpers.cs | 29 ---------------- .../Models/MethodSignatureMarshallingFacts.cs | 5 ++- .../Resolvers/ParameterCategoryResolver.cs | 3 +- 6 files changed, 48 insertions(+), 50 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 17ab959a0..0ef3c9a75 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -150,6 +150,35 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) resolver.IsRuntimeClassOrInterface(sig); } + /// + /// Strips trailing and + /// wrappers from the signature, returning the underlying signature. + /// + /// The underlying signature with byref + custom-modifier wrappers stripped. + public TypeSignature StripByRefAndCustomModifiers() + { + TypeSignature current = sig; + + while (true) + { + if (current is ByReferenceTypeSignature br) + { + current = br.BaseType; + + continue; + } + + if (current is CustomModifierTypeSignature cm) + { + current = cm.BaseType; + + continue; + } + + return current; + } + } + /// /// Strips byref + custom modifiers from the input signature and returns the result /// as an if the underlying type is one; otherwise @@ -157,7 +186,7 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) /// public SzArrayTypeSignature? AsSzArray() { - return Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig) as SzArrayTypeSignature; + return sig.StripByRefAndCustomModifiers() as SzArrayTypeSignature; } /// @@ -167,7 +196,7 @@ public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) /// public TypeSignature? SzArrayElement() { - return (Helpers.AbiTypeHelpers.StripByRefAndCustomModifiers(sig) as SzArrayTypeSignature)?.BaseType; + return (sig.StripByRefAndCustomModifiers() as SzArrayTypeSignature)?.BaseType; } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 0e8e6b36d..17a0e78cc 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -84,7 +84,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.Out)) { - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); if (!uOut.IsGenericInstance()) { @@ -182,7 +182,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Use the projected (non-ABI) type for the local variable. // Strip ByRef and CustomModifier wrappers to get the underlying base type. - TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature underlying = p.Type.StripByRefAndCustomModifiers(); WriteProjectedSignatureCallback projected = MethodFactory.WriteProjectedSignature(context, underlying, false); writer.WriteLine($"{projected} __{raw} = default;"); } @@ -388,7 +388,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // marshaller — DO NOT zero or write back. string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); - TypeSignature uRef = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uRef = p.Type.StripByRefAndCustomModifiers(); if (uRef.IsString()) { @@ -449,7 +449,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); - TypeSignature underlying = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature underlying = p.Type.StripByRefAndCustomModifiers(); string rhs; // String: HStringMarshaller.ConvertToUnmanaged diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index e059df8a9..a870a015d 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -63,7 +63,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.Out) { - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); _ = fp.Append(", "); if (uOut.IsAbiRefLike(context.AbiTypeShapeResolver)) @@ -92,7 +92,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.Ref) { - TypeSignature uRef = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uRef = p.Type.StripByRefAndCustomModifiers(); _ = fp.Append(", "); if (context.AbiTypeShapeResolver.IsComplexStruct(uRef)) @@ -296,7 +296,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - TypeSignature pType = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); if (!context.AbiTypeShapeResolver.IsComplexStruct(pType)) { @@ -313,7 +313,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string localName = p.GetParamLocalName(paramNameOverride); - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); string abi = AbiTypeHelpers.GetAbiLocalTypeName(context, uOut); writer.WriteLine($"{abi} __{localName} = default;"); } @@ -462,7 +462,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - TypeSignature pType = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); if (!context.AbiTypeShapeResolver.IsComplexStruct(pType)) { @@ -540,7 +540,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.Ref) { - TypeSignature uRefSkip = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uRefSkip = p.Type.StripByRefAndCustomModifiers(); if (context.AbiTypeShapeResolver.IsComplexStruct(uRefSkip)) { @@ -797,7 +797,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec if (cat == ParameterCategory.Ref) { string localName = p.GetParamLocalName(paramNameOverride); - TypeSignature uRefArg = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uRefArg = p.Type.StripByRefAndCustomModifiers(); if (context.AbiTypeShapeResolver.IsComplexStruct(uRefArg)) { @@ -921,7 +921,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); // For Out generic instance: emit inline UnsafeAccessor to ConvertToManaged_ // before the writeback. (e.g. Collection1HandlerInvoke @@ -1130,7 +1130,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - TypeSignature pType = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); if (!context.AbiTypeShapeResolver.IsComplexStruct(pType)) { @@ -1278,7 +1278,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); string localName = p.GetParamLocalName(paramNameOverride); if (uOut.IsString()) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index ecd0f416e..3a42e3f46 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -271,33 +271,4 @@ public static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) && (a.Name?.Value ?? string.Empty) == (b.Name?.Value ?? string.Empty); } - /// - /// Strips trailing and - /// wrappers from the signature, returning the underlying signature (or - /// if the input is ). - /// - /// The underlying signature with byref + custom-modifier wrappers stripped. - public static TypeSignature StripByRefAndCustomModifiers(TypeSignature sig) - { - TypeSignature current = sig; - - while (true) - { - if (current is ByReferenceTypeSignature br) - { - current = br.BaseType; - - continue; - } - - if (current is CustomModifierTypeSignature cm) - { - current = cm.BaseType; - - continue; - } - - return current; - } - } } diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index da1b3f499..6cdf41201 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -2,7 +2,6 @@ // Licensed under the MIT License. using AsmResolver.DotNet.Signatures; -using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Resolvers; namespace WindowsRuntime.ProjectionWriter.Models; @@ -79,7 +78,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT { if (!hasOutNeedsCleanup && cat == ParameterCategory.Out) { - TypeSignature uOut = AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type); + TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); if (uOut.IsAbiArrayElementRefLike(resolver) || uOut.IsSystemType() || resolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) { @@ -101,7 +100,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT } if (!hasComplexStructInput && (cat is ParameterCategory.In or ParameterCategory.Ref) - && resolver.IsComplexStruct(AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type))) + && resolver.IsComplexStruct(p.Type.StripByRefAndCustomModifiers())) { hasComplexStructInput = true; } diff --git a/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs b/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs index 80e7aa3ca..3fc87dd29 100644 --- a/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs @@ -2,7 +2,6 @@ // Licensed under the MIT License. using AsmResolver.DotNet.Signatures; -using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Models; namespace WindowsRuntime.ProjectionWriter.Resolvers; @@ -31,7 +30,7 @@ public static ParameterCategory GetParamCategory(ParameterInfo p) // If byref and underlying is an array, treat as array param (PassArray/ReceiveArray/FillArray) // based on in/out flags. WinRT metadata represents 'out byte[]' as 'byte[]&' with [out]. - bool isByRefArray = isByRef && AbiTypeHelpers.StripByRefAndCustomModifiers(p.Type) is SzArrayTypeSignature; + bool isByRefArray = isByRef && p.Type.StripByRefAndCustomModifiers() is SzArrayTypeSignature; if (isArray || isByRefArray) { From be5c59f23a6bcba8687703f7a370f7bd58d32c50 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:13:19 -0700 Subject: [PATCH 134/171] Add IsByValue() ParameterCategory predicate M17: Add IsByValue() to ParameterCategoryExtensions returning true for ParameterCategory.In or Ref (scalar by-value parameters that the callee reads). Use at 4 sites: - AbiMethodBodyFactory.RcwCaller (3 sites) - MethodSignatureMarshallingFacts (1 site) Name picked per project preference (IsByValue over IsScalarInput) to mirror the existing IsArrayInput()/IsAnyArray() naming. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ParameterCategoryExtensions.cs | 10 ++++++++++ .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 6 +++--- .../Models/MethodSignatureMarshallingFacts.cs | 2 +- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs index 67eb04585..4b50054fc 100644 --- a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs @@ -22,6 +22,16 @@ public bool IsArrayInput() return category is ParameterCategory.PassArray or ParameterCategory.FillArray; } + /// + /// Returns whether the input category is a scalar by-value parameter that the callee + /// reads ( or ) — + /// i.e. not an array, not an output parameter, and not a receive-array. + /// + public bool IsByValue() + { + return category is ParameterCategory.In or ParameterCategory.Ref; + } + /// /// Returns whether the input category is any of the array-shaped categories /// (, , diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index a870a015d..649b2d70e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -291,7 +291,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.In or ParameterCategory.Ref)) + if (!cat.IsByValue()) { continue; } @@ -457,7 +457,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.In or ParameterCategory.Ref)) + if (!cat.IsByValue()) { continue; } @@ -1125,7 +1125,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.In or ParameterCategory.Ref)) + if (!cat.IsByValue()) { continue; } diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index 6cdf41201..504360b6a 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -99,7 +99,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT hasNonBlittablePassArray = true; } - if (!hasComplexStructInput && (cat is ParameterCategory.In or ParameterCategory.Ref) + if (!hasComplexStructInput && cat.IsByValue() && resolver.IsComplexStruct(p.Type.StripByRefAndCustomModifiers())) { hasComplexStructInput = true; From 79439e070d67423937955f28f527c19105045a5e Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:13:58 -0700 Subject: [PATCH 135/171] Use IsArrayInput() at 9 ParameterCategory filter sites M3.1: Replace inline 'cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)' pattern with '!cat.IsArrayInput()' at 9 sites that pre-filter for non-array parameters: - AbiMethodBodyFactory.DoAbi (3 sites) - AbiMethodBodyFactory.RcwCaller (3 sites) - ConstructorFactory.FactoryCallbacks (3 sites) The IsArrayInput() extension already exists and is in use elsewhere; this consolidates the remaining inline duplication. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 6 +++--- .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 6 +++--- .../Factories/ConstructorFactory.FactoryCallbacks.cs | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 17a0e78cc..fe8974ad2 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -213,7 +213,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } @@ -621,7 +621,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } @@ -652,7 +652,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 649b2d70e..ae00c57cd 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -342,7 +342,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } @@ -660,7 +660,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } @@ -1151,7 +1151,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 215e6be12..eaf717652 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -253,7 +253,7 @@ public override unsafe void Invoke( ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } @@ -433,7 +433,7 @@ public override unsafe void Invoke( ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } @@ -598,7 +598,7 @@ public override unsafe void Invoke( ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (cat is not (ParameterCategory.PassArray or ParameterCategory.FillArray)) + if (!cat.IsArrayInput()) { continue; } From 1d1cca904b2590afb09a3ccf97cfa7c48e07a35a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:18:53 -0700 Subject: [PATCH 136/171] Add BuildGlobalQualifiedName helper for global::Ns.Name composition M4: Add a small static string helper BuildGlobalQualifiedName(ns, name) to TypedefNameWriter that returns 'global::Ns.Name', or 'global::Name' when ns is null or empty. Replace 10 inline occurrences of the pattern across the writer: - AbiClassFactory.cs (3 sites) - AbiDelegateFactory.cs (2 sites) - ComponentFactory.cs (1 site, collapses 2-branch ternary) - ClassMembersFactory.cs (2 sites, single-statement writer.Write) - MetadataAttributeFactory.cs (2 sites) Per project preference, the helper is string-only (no AsmResolver overload). The 3 conditional writer-form sites in InterfaceFactory (which only emit 'global::Ns.' when ns differs from the current namespace) don't fit this simple helper and are left as-is. This also fixes a latent inconsistency: most pre-existing sites would have emitted 'global::.Name' for a global-namespace type because they didn't guard against an empty namespace. The new helper handles the empty-namespace case uniformly. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiClassFactory.cs | 6 +++--- .../Factories/AbiDelegateFactory.cs | 4 ++-- .../Factories/ClassMembersFactory.cs | 4 ++-- .../Factories/ComponentFactory.cs | 4 +--- .../Factories/MetadataAttributeFactory.cs | 4 ++-- .../Helpers/TypedefNameWriter.cs | 11 +++++++++++ 6 files changed, 21 insertions(+), 12 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 98bd48fb5..c5476e628 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -50,7 +50,7 @@ internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, Pr { string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; - string projectedType = $"global::{typeNs}.{nameStripped}"; + string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); @@ -116,7 +116,7 @@ internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, Proje { string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; - string projectedType = string.IsNullOrEmpty(typeNs) ? $"global::{nameStripped}" : $"global::{typeNs}.{nameStripped}"; + string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; TypeCategory category = TypeCategorization.GetCategory(type); @@ -200,7 +200,7 @@ internal static void WriteClassMarshallerStub(IndentedTextWriter writer, Project { string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; - string fullProjected = $"global::{typeNs}.{nameStripped}"; + string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); // Get the IID expression for the default interface (used by CreateObject). ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index c0606ce59..771dd6831 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -313,7 +313,7 @@ private static void WriteDelegateMarshallerOnly(IndentedTextWriter writer, Proje { string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; - string fullProjected = $"global::{typeNs}.{nameStripped}"; + string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); writer.WriteLine(); @@ -346,7 +346,7 @@ private static void WriteDelegateComWrappersCallback(IndentedTextWriter writer, { string nameStripped = type.GetStrippedName(); string typeNs = type.Namespace?.Value ?? string.Empty; - string fullProjected = $"global::{typeNs}.{nameStripped}"; + string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 3bb6d6895..5bc71173a 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -142,7 +142,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro (string ns, string name) = tr.Names(); _ = MappedTypes.ApplyMapping(ref ns, ref name); - writer.Write($"global::{ns}.{IdentifierEscaping.StripBackticks(name)}"); + writer.Write(TypedefNameWriter.BuildGlobalQualifiedName(ns, IdentifierEscaping.StripBackticks(name))); } else if (ifaceType.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { @@ -150,7 +150,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro (string ns, string name) = gt.Names(); _ = MappedTypes.ApplyMapping(ref ns, ref name); - writer.Write($"global::{ns}.{IdentifierEscaping.StripBackticks(name)}<"); + writer.Write($"{TypedefNameWriter.BuildGlobalQualifiedName(ns, IdentifierEscaping.StripBackticks(name))}<"); for (int i = 0; i < gi.TypeArguments.Count; i++) { writer.WriteIf(i > 0, ", "); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 655883f45..afb6b9dab 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -51,9 +51,7 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo { string typeName = type.Name?.Value ?? string.Empty; string typeNs = type.Namespace?.Value ?? string.Empty; - string projectedTypeName = string.IsNullOrEmpty(typeNs) - ? $"global::{IdentifierEscaping.StripBackticks(typeName)}" - : $"global::{typeNs}.{IdentifierEscaping.StripBackticks(typeName)}"; + string projectedTypeName = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, IdentifierEscaping.StripBackticks(typeName)); string factoryTypeName = $"{IdentifierEscaping.StripBackticks(typeName)}ServerActivationFactory"; bool isActivatable = !TypeCategorization.IsStatic(type) && type.HasDefaultConstructor(); diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 1aad438ec..fcb4b9758 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -423,7 +423,7 @@ public static void AddDefaultInterfaceEntry(ProjectionEmitContext context, TypeD } (string typeNs, string typeName) = type.Names(); - string className = $"global::{typeNs}.{IdentifierEscaping.StripBackticks(typeName)}"; + string className = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, IdentifierEscaping.StripBackticks(typeName)); // Resolve TypeReference -> TypeDefinition so WriteTypeName goes through the Definition // branch which knows about authored-type CCW namespacing (ABI.Impl. prefix). @@ -457,7 +457,7 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, } (string typeNs, string typeName) = type.Names(); - string className = $"global::{typeNs}.{IdentifierEscaping.StripBackticks(typeName)}"; + string className = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, IdentifierEscaping.StripBackticks(typeName)); foreach (InterfaceImplementation impl in type.Interfaces) { diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index f2637ec1e..41c468cd2 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -18,6 +18,17 @@ namespace WindowsRuntime.ProjectionWriter.Helpers; /// internal static class TypedefNameWriter { + /// + /// Builds the fully-qualified global::Ns.Name form for a type, handling the empty-namespace case. + /// + /// The type's namespace (may be or empty for top-level types). + /// The type's name (already stripped of backticks if applicable). + /// The string global::Name when is null/empty, otherwise global::Ns.Name. + public static string BuildGlobalQualifiedName(string? ns, string name) + { + return string.IsNullOrEmpty(ns) ? $"global::{name}" : $"global::{ns}.{name}"; + } + /// /// Writes a fundamental (primitive) type's projected name. /// From 186397845340c081637c921e67ac86a3a1c2144f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:20:45 -0700 Subject: [PATCH 137/171] Add IsReferenceTypeOrGenericInstance shape predicate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit M12.1: Add IsReferenceTypeOrGenericInstance(TypeSignature) to AbiTypeShapeResolver as a combined predicate for the recurring 3-part check: runtime class / interface / delegate, plus System.Object, plus any closed generic instance. These are the reference-type shapes that cross the WinRT ABI as opaque pointers. Replace 3 inline occurrences: - AbiMethodBodyFactory.DoAbi (1 site, returnIsRefType local) - AbiMethodBodyFactory.RcwCaller (1 site, GetThisPtrUnsafe branch) - ConstructorFactory.FactoryCallbacks (1 site, GetThisPtrUnsafe branch) The two 2-part sites (DoAbi.cs:716, RcwCaller.cs:213) are intentionally NOT 3-part — they sit in an else-if chain where a prior branch already handles the generic-instance case — so they are left alone. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 2 +- .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 2 +- .../Factories/ConstructorFactory.FactoryCallbacks.cs | 2 +- .../Resolvers/AbiTypeShapeResolver.cs | 10 ++++++++++ 4 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index fe8974ad2..f620d35eb 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -31,7 +31,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection || context.AbiTypeShapeResolver.IsComplexStruct(retSzAbi.BaseType)); bool returnIsHResultExceptionDoAbi = rt is not null && rt.IsHResultException(); bool returnIsString = rt is not null && rt.IsString(); - bool returnIsRefType = rt is not null && (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(rt) || rt.IsObject() || rt.IsGenericInstance()); + bool returnIsRefType = rt is not null && context.AbiTypeShapeResolver.IsReferenceTypeOrGenericInstance(rt); bool returnIsGenericInstance = rt is not null && rt.IsGenericInstance(); bool returnIsBlittableStruct = rt is not null && context.AbiTypeShapeResolver.IsBlittableStruct(rt); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index ae00c57cd..e56e35681 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -829,7 +829,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.HString"); } - else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject() || p.Type.IsGenericInstance()) + else if (context.AbiTypeShapeResolver.IsReferenceTypeOrGenericInstance(p.Type)) { writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.GetThisPtrUnsafe()"); } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index eaf717652..c69757ee5 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -538,7 +538,7 @@ public override unsafe void Invoke( { writer.Write($"__{raw}.ConvertToUnmanagedUnsafe()"); } - else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject() || p.Type.IsGenericInstance()) + else if (context.AbiTypeShapeResolver.IsReferenceTypeOrGenericInstance(p.Type)) { writer.Write($"__{raw}.GetThisPtrUnsafe()"); } diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs index 5ec814800..3a8ab3c5b 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs @@ -93,6 +93,16 @@ public bool IsComplexStruct(TypeSignature signature) public bool IsRuntimeClassOrInterface(TypeSignature signature) => Resolve(signature).Kind is AbiTypeShapeKind.RuntimeClassOrInterface or AbiTypeShapeKind.Delegate; + /// + /// Returns whether is a reference type that crosses the ABI as + /// an opaque pointer — either a runtime class / interface / delegate, the base + /// type, or any closed generic instance. + /// + /// The type signature to classify. + /// if a reference type or generic instance; otherwise . + public bool IsReferenceTypeOrGenericInstance(TypeSignature signature) + => IsRuntimeClassOrInterface(signature) || signature.IsObject() || signature.IsGenericInstance(); + /// /// Returns whether is a mapped value type that needs ABI-specific /// marshalling (Windows.Foundation.DateTime, Windows.Foundation.TimeSpan). From b13a0aea2c2310b2201398860c5d2447db15b3b0 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:22:11 -0700 Subject: [PATCH 138/171] Simplify GetExclusiveToType and AttributedTypes.GetSystemType M14: Simplify two custom-attribute readers now that GetWindowsFoundationMetadataAttribute and TryGetFixedArgument are available. AbiTypeHelpers.GetExclusiveToType collapses from a 49-line manual attribute scan to a handful of lines: fetch the WindowsFoundationMetadata ExclusiveToAttribute, read the first positional arg as a TypeSignature, look up the resolved TypeDefinition in the metadata cache. AttributedTypes.GetSystemType (the per-attribute System.Type extractor used by [Activatable]/[Static]/[Composable]) shrinks similarly to 7 lines reading the first positional TypeSignature. The previous fallback branches that read the System.Type argument as a 'string' are dropped: WinMD System.Type arguments are always serialized as TypeSignature, never as string literals. The extra branches were unreachable in practice. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Helpers/AbiTypeHelpers.cs | 52 +++---------------- .../Helpers/AttributedTypes.cs | 29 +---------- 2 files changed, 8 insertions(+), 73 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 3a42e3f46..0e493d24f 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -11,7 +11,6 @@ using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -26,53 +25,14 @@ internal static partial class AbiTypeHelpers /// public static TypeDefinition? GetExclusiveToType(MetadataCache cache, TypeDefinition iface) { - for (int i = 0; i < iface.CustomAttributes.Count; i++) - { - CustomAttribute attr = iface.CustomAttributes[i]; - ITypeDefOrRef? attrType = attr.Constructor?.DeclaringType; - - if (attrType is null) - { - continue; - } + CustomAttribute? attr = iface.GetWindowsFoundationMetadataAttribute(ExclusiveToAttribute); - if (attrType.Namespace?.Value != WindowsFoundationMetadata || - attrType.Name?.Value != ExclusiveToAttribute) - { - continue; - } - - if (attr.Signature is null) - { - continue; - } - - for (int j = 0; j < attr.Signature.FixedArguments.Count; j++) - { - CustomAttributeArgument arg = attr.Signature.FixedArguments[j]; - - if (arg.Element is TypeSignature sig) - { - string fullName = sig.FullName ?? string.Empty; - TypeDefinition? td = cache.Find(fullName); - - if (td is not null) - { - return td; - } - } - else if (arg.Element is string s) - { - TypeDefinition? td = cache.Find(s); - - if (td is not null) - { - return td; - } - } - } + if (attr is null || !attr.TryGetFixedArgument(0, out TypeSignature? sig)) + { + return null; } - return null; + + return cache.Find(sig.FullName ?? string.Empty); } /// diff --git a/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs b/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs index 620aaba7d..2e1dbf94e 100644 --- a/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs @@ -89,37 +89,12 @@ public static IEnumerable> Get(TypeDefiniti /// private static TypeDefinition? GetSystemType(CustomAttribute attr, MetadataCache cache) { - if (attr.Signature is null) + if (!attr.TryGetFixedArgument(0, out TypeSignature? sig)) { return null; } - for (int i = 0; i < attr.Signature.FixedArguments.Count; i++) - { - CustomAttributeArgument arg = attr.Signature.FixedArguments[i]; - - // For System.Type args in WinMD, the value is typically a TypeSignature - if (arg.Element is TypeSignature sig) - { - string typeName = sig.FullName ?? string.Empty; - TypeDefinition? td = cache.Find(typeName); - - if (td is not null) - { - return td; - } - } - else if (arg.Element is string s) - { - TypeDefinition? td = cache.Find(s); - - if (td is not null) - { - return td; - } - } - } - return null; + return cache.Find(sig.FullName ?? string.Empty); } /// From 1cd5a0b163fa9e4ea06b49dc3f583e088eb3afa3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:24:11 -0700 Subject: [PATCH 139/171] Delete ClassMembersFactory.ResolveInterface (redundant) M15: Delete the private ClassMembersFactory.ResolveInterface(MetadataCache, ITypeDefOrRef) helper. The same logic is already available via two extensions: - ITypeDefOrRefExtensions.ResolveAsTypeDefinition(MetadataCache) - InterfaceImplementationExtensions.TryResolveTypeDef(MetadataCache, out TypeDefinition) Migrate all 4 callers to use the InterfaceImplementation form since they all start from impl.Interface and already need a null-check: - ClassMembersFactory.IsInterfaceInInheritanceList - ClassMembersFactory.WriteInterfaceMembers.cs (interface walk) - InterfaceFactory (overridable/exclusive scan) - InterfaceFactory (setter-defining-interface walk) The dropped TryResolve(cache.RuntimeContext) fallback was never reached in practice for any of the projection scenarios we exercise: byte-identical output across all 3 RSP scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- ...assMembersFactory.WriteInterfaceMembers.cs | 4 +-- .../Factories/ClassMembersFactory.cs | 33 +------------------ .../Factories/InterfaceFactory.cs | 8 ++--- 3 files changed, 4 insertions(+), 41 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index afb640ae3..8ee209fcd 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -34,9 +34,7 @@ private static void WriteInterfaceMembersRecursive(IndentedTextWriter writer, Pr } // Resolve TypeRef to TypeDef using our cache - TypeDefinition? ifaceType = ResolveInterface(context.Cache, impl.Interface); - - if (ifaceType is null) + if (!impl.TryResolveTypeDef(context.Cache, out TypeDefinition? ifaceType)) { continue; } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 5bc71173a..c8f101f55 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -47,44 +47,13 @@ internal static bool IsInterfaceInInheritanceList(MetadataCache cache, Interface return true; } - TypeDefinition? td = ResolveInterface(cache, impl.Interface); - - if (td is null) + if (!impl.TryResolveTypeDef(cache, out TypeDefinition? td)) { return true; } return !TypeCategorization.IsExclusiveTo(td); } - internal static TypeDefinition? ResolveInterface(MetadataCache cache, ITypeDefOrRef typeRef) - { - if (typeRef is TypeDefinition td) - { - return td; - } - - TypeDefinition? resolved = typeRef.TryResolve(cache.RuntimeContext); - - if (resolved is not null) - { - return resolved; - } - - // Fall back to local lookup by full name - if (typeRef is TypeReference tr) - { - (string ns, string name) = tr.Names(); - string fullName = string.IsNullOrEmpty(ns) ? name : ns + "." + name; - return cache.Find(fullName); - } - - if (typeRef.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) - { - return ResolveInterface(cache, gi.GenericType); - } - - return null; - } /// /// A callback emitting the parameter name with its modifier. diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 6a4ed90cb..cea063667 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -103,9 +103,7 @@ public static void WriteTypeInheritance(IndentedTextWriter writer, ProjectionEmi } else { - TypeDefinition? resolved = ClassMembersFactory.ResolveInterface(context.Cache, impl.Interface); - - if (resolved is not null) + if (impl.TryResolveTypeDef(context.Cache, out TypeDefinition? resolved)) { isExclusive = TypeCategorization.IsExclusiveTo(resolved); } @@ -286,9 +284,7 @@ private static bool TryFindPropertyInBaseInterfacesRecursive(MetadataCache cache continue; } - TypeDefinition? baseIface = ClassMembersFactory.ResolveInterface(cache, impl.Interface); - - if (baseIface is null) + if (!impl.TryResolveTypeDef(cache, out TypeDefinition? baseIface)) { continue; } From 97c10da71d15f937aa740b7c5c5c13234cccb7e5 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:46:39 -0700 Subject: [PATCH 140/171] Consolidate [UnsafeAccessor] extern emissions into UnsafeAccessorFactory Centralises ~22 ad-hoc [UnsafeAccessor] static-extern declaration emit sites and the IID accessor emission into a new UnsafeAccessorFactory. * Adds Factories/UnsafeAccessorFactory.cs with three public emitters: - EmitStaticMethod (UnsafeAccessorKind.StaticMethod over object _) - EmitConstructorReturningObject (UnsafeAccessorKind.Constructor + [return: UnsafeAccessorType(...)]) - EmitIidAccessor (writer + string-overload) -- moved from ObjRefNameGenerator so the IID extern declaration sits alongside the other [UnsafeAccessor] emitters. * Migrates ~24 call sites to the factory across: - AbiClassFactory - AbiMethodBodyFactory.MethodsClass - AbiMethodBodyFactory.DoAbi - AbiMethodBodyFactory.RcwCaller - ConstructorFactory.FactoryCallbacks - EventTableFactory - ClassMembersFactory.WriteClassMembers - ClassMembersFactory.WriteInterfaceMembers - MappedInterfaceStubFactory (private helper now delegates) Sites that bake +4 extra indent into the raw string for a staggered visual layout (3 DoAbi.cs CopyToManaged sites + the RcwCaller Dispose site whose disposeDataParamType needs a mid-stream WriteIf) are left inline; consolidating them would require either an additional factory variant for the staggered form, or a cosmetic change to the output. Both options are out-of-scope for the consolidation pass. * ObjRefNameGenerator.EmitUnsafeAccessorForIid (writer + string overloads) is deleted; the only remaining BuildIidPropertyNameForGenericInterface helper stays. Build clean (0 warnings, 0 errors). Validate-All reports 0 diffs across pushnot, everything-with-ui, and windows scenarios. Closes M8 from the duplication-analysis report. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiClassFactory.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 44 ++++--- .../AbiMethodBodyFactory.MethodsClass.cs | 24 ++-- .../AbiMethodBodyFactory.RcwCaller.cs | 119 +++++++++++------- .../ClassMembersFactory.WriteClassMembers.cs | 22 ++-- ...assMembersFactory.WriteInterfaceMembers.cs | 23 ++-- .../ConstructorFactory.FactoryCallbacks.cs | 37 ++++-- .../Factories/EventTableFactory.cs | 17 ++- .../Factories/MappedInterfaceStubFactory.cs | 11 +- .../Factories/UnsafeAccessorFactory.cs | 115 +++++++++++++++++ .../Helpers/ObjRefNameGenerator.cs | 42 +------ 11 files changed, 307 insertions(+), 149 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Factories/UnsafeAccessorFactory.cs diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index c5476e628..1498f0308 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -93,7 +93,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedT // marshallers run inside #nullable enable) if the type is a generic type. if (defaultGenericInst is not null) { - ObjRefNameGenerator.EmitUnsafeAccessorForIid(writer, context, defaultGenericInst, isInNullableContext: true); + UnsafeAccessorFactory.EmitIidAccessor(writer, context, defaultGenericInst, isInNullableContext: true); } writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index f620d35eb..7c120c3df 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -71,10 +71,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(rt!, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt!, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToUnmanaged", + returnType: "WindowsRuntimeObjectReferenceValue", + functionName: $"ConvertToUnmanaged_{retParamName}", + interopType: interopTypeName, + parameterList: $", {projectedTypeName.Format()} value"); writer.WriteLine(); } @@ -94,10 +97,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(uOut, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToUnmanaged", + returnType: "WindowsRuntimeObjectReferenceValue", + functionName: $"ConvertToUnmanaged_{raw}", + interopType: interopTypeName, + parameterList: $", {projectedTypeName.Format()} value"); writer.WriteLine(); } @@ -113,10 +119,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, sza.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern void ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToUnmanaged", + returnType: "void", + functionName: $"ConvertToUnmanaged_{raw}", + interopType: marshallerPath, + parameterList: $", ReadOnlySpan<{elementProjected.Format()}> span, out uint length, out {elementAbi}* data"); writer.WriteLine(); } @@ -125,10 +134,13 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSzHoist.BaseType)); string elementAbi = AbiTypeHelpers.GetAbiLocalTypeName(context, retSzHoist.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(retSzHoist.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern void ConvertToUnmanaged_{{retParamName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, ReadOnlySpan<{{elementProjected}}> span, out uint length, out {{elementAbi}}* data); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToUnmanaged", + returnType: "void", + functionName: $"ConvertToUnmanaged_{retParamName}", + interopType: marshallerPath, + parameterList: $", ReadOnlySpan<{elementProjected.Format()}> span, out uint length, out {elementAbi}* data"); writer.WriteLine(); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index 1f7dcdf81..b2e0a1cd5 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -27,7 +27,7 @@ internal static void EmitUnsafeAccessorForDefaultIfaceIfGeneric(IndentedTextWrit { if (defaultIface is not null && defaultIface.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { - ObjRefNameGenerator.EmitUnsafeAccessorForIid(writer, context, gi); + UnsafeAccessorFactory.EmitIidAccessor(writer, context, gi); } } @@ -171,16 +171,22 @@ public static unsafe """); if (isGenericEvent && !string.IsNullOrEmpty(eventSourceInteropType)) { + writer.IncreaseIndent(); + writer.IncreaseIndent(); + UnsafeAccessorFactory.EmitConstructorReturningObject( + writer, + interopType: eventSourceInteropType, + functionName: "ctor", + parameterList: "WindowsRuntimeObjectReference nativeObjectReference, int index"); + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.Constructor)] - [return: UnsafeAccessorType("{{eventSourceInteropType}}")] - static extern object ctor(WindowsRuntimeObjectReference nativeObjectReference, int index); - - return _{{evtName}}.GetOrAdd( - key: thisObject, - valueFactory: static (_, thisReference) => Unsafe.As<{{eventSourceProjectedFull}}>(ctor(thisReference, {{eventSlot.ToString(CultureInfo.InvariantCulture)}})), - factoryArgument: thisReference); + return _{{evtName}}.GetOrAdd( + key: thisObject, + valueFactory: static (_, thisReference) => Unsafe.As<{{eventSourceProjectedFull}}>(ctor(thisReference, {{eventSlot.ToString(CultureInfo.InvariantCulture)}})), + factoryArgument: thisReference); """); + writer.DecreaseIndent(); + writer.DecreaseIndent(); } else { diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index e56e35681..e7fe959d9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -232,11 +232,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = p.GetParamName(paramNameOverride); string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - using WindowsRuntimeObjectReferenceValue __{{localName}} = ConvertToUnmanaged_{{localName}}(null, {{callName}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToUnmanaged", + returnType: "WindowsRuntimeObjectReferenceValue", + functionName: $"ConvertToUnmanaged_{localName}", + interopType: interopTypeName, + parameterList: $", {projectedTypeName.Format()} value"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{localName} = ConvertToUnmanaged_{localName}(null, {callName});"); } } @@ -739,11 +742,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec dataCastType = "(void**)"; } - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - static extern void CopyToUnmanaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, {{dataParamType}} data); - CopyToUnmanaged_{{localName}}(null, {{callName}}, (uint){{callName}}.Length, {{dataCastType}}_{{localName}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "CopyToUnmanaged", + returnType: "void", + functionName: $"CopyToUnmanaged_{localName}", + interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType), + parameterList: $", ReadOnlySpan<{elementProjected.Format()}> span, uint length, {dataParamType} data"); + writer.WriteLine($"CopyToUnmanaged_{localName}(null, {callName}, (uint){callName}.Length, {dataCastType}_{localName});"); } } @@ -907,11 +913,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToManaged")] - static extern void CopyToManaged_{{localName}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType)}}")] object _, uint length, {{elementAbi}}* data, Span<{{elementProjected}}> span); - CopyToManaged_{{localName}}(null, (uint){{names.Span}}.Length, ({{elementAbi}}*)_{{localName}}, {{callName}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "CopyToManaged", + returnType: "void", + functionName: $"CopyToManaged_{localName}", + interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(szFA.BaseType), + parameterList: $", uint length, {elementAbi}* data, Span<{elementProjected.Format()}> span"); + writer.WriteLine($"CopyToManaged_{localName}(null, (uint){names.Span}.Length, ({elementAbi}*)_{localName}, {callName});"); } // After call: write back Out params to caller's 'out' var. @@ -930,11 +939,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(uOut, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, uOut, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{projectedTypeName}} ConvertToManaged_{{localName}}([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - {{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToManaged", + returnType: projectedTypeName.Format(), + functionName: $"ConvertToManaged_{localName}", + interopType: interopTypeName, + parameterList: ", void* value"); + writer.WriteLine($"{callName} = ConvertToManaged_{localName}(null, __{localName});"); continue; } @@ -1000,11 +1012,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // complex structs, blittable struct ABI for blittable structs, primitive ABI otherwise). string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{elementProjected}}[] ConvertToManaged_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); - {{callName}} = ConvertToManaged_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToManaged", + returnType: $"{elementProjected.Format()}[]", + functionName: $"ConvertToManaged_{localName}", + interopType: marshallerPath, + parameterList: $", uint length, {elementAbi}* data"); + writer.WriteLine($"{callName} = ConvertToManaged_{localName}(null, __{localName}_length, __{localName}_data);"); } if (rt is not null) @@ -1014,11 +1029,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt; WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(retSz.BaseType)); string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{elementProjected}}[] ConvertToManaged_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); - return ConvertToManaged_retval(null, __retval_length, __retval_data); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToManaged", + returnType: $"{elementProjected.Format()}[]", + functionName: "ConvertToManaged_retval", + interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType), + parameterList: $", uint length, {elementAbi}* data"); + writer.WriteLine("return ConvertToManaged_retval(null, __retval_length, __retval_data);"); } else if (returnIsHResultException) { @@ -1041,11 +1059,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(rt, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, rt, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{projectedTypeName}} ConvertToManaged_retval([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - return ConvertToManaged_retval(null, __retval); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToManaged", + returnType: projectedTypeName.Format(), + functionName: "ConvertToManaged_retval", + interopType: interopTypeName, + parameterList: ", void* value"); + writer.WriteLine("return ConvertToManaged_retval(null, __retval);"); } else { @@ -1310,12 +1331,15 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Element ABI type: same dispatch as the ConvertToManaged_ path. string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, sza.BaseType); string marshallerPath = ArrayElementEncoder.GetArrayMarshallerInteropPath(sza.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] - static extern void Free_{{localName}}([UnsafeAccessorType("{{marshallerPath}}")] object _, uint length, {{elementAbi}}* data); - - Free_{{localName}}(null, __{{localName}}_length, __{{localName}}_data); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "Free", + returnType: "void", + functionName: $"Free_{localName}", + interopType: marshallerPath, + parameterList: $", uint length, {elementAbi}* data"); + writer.WriteLine(); + writer.WriteLine($"Free_{localName}(null, __{localName}_length, __{localName}_data);"); } // 4. Free return value (__retval) — emitted last to match truth ordering. @@ -1340,11 +1364,14 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { SzArrayTypeSignature retSz = (SzArrayTypeSignature)rt!; string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, retSz.BaseType); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Free")] - static extern void Free_retval([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType)}}")] object _, uint length, {{elementAbi}}* data); - Free_retval(null, __retval_length, __retval_data); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "Free", + returnType: "void", + functionName: "Free_retval", + interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(retSz.BaseType), + parameterList: $", uint length, {elementAbi}* data"); + writer.WriteLine("Free_retval(null, __retval_length, __retval_data);"); } } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs index 18854268f..b21ff1516 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteClassMembers.cs @@ -44,19 +44,25 @@ public static void WriteClassMembers(IndentedTextWriter writer, ProjectionEmitCo if (s.HasGetter && s.GetterIsGeneric && !string.IsNullOrEmpty(s.GetterGenericInteropType)) { writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{kvp.Key}}")] - static extern {{s.GetterPropTypeText}} {{s.GetterGenericAccessorName}}([UnsafeAccessorType("{{s.GetterGenericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: kvp.Key, + returnType: s.GetterPropTypeText, + functionName: s.GetterGenericAccessorName, + interopType: s.GetterGenericInteropType, + parameterList: ", WindowsRuntimeObjectReference thisReference"); } if (s.HasSetter && s.SetterIsGeneric && !string.IsNullOrEmpty(s.SetterGenericInteropType)) { writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{kvp.Key}}")] - static extern void {{s.SetterGenericAccessorName}}([UnsafeAccessorType("{{s.SetterGenericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference, {{s.SetterPropTypeText}} value); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: kvp.Key, + returnType: "void", + functionName: s.SetterGenericAccessorName, + interopType: s.SetterGenericInteropType, + parameterList: $", WindowsRuntimeObjectReference thisReference, {s.SetterPropTypeText} value"); } writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 8ee209fcd..8dffae7df 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -310,9 +310,14 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE string platformTrimmed = platformAttribute.TrimEnd('\r', '\n'); writer.WriteLine(); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: name, + returnType: unsafeRet.Format(), + functionName: accessorName, + interopType: genericInteropType, + parameterList: $", WindowsRuntimeObjectReference thisReference{accessorParams}"); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{name}}")] - static extern {{unsafeRet}} {{accessorName}}([UnsafeAccessorType("{{genericInteropType}}")] object _, WindowsRuntimeObjectReference thisReference{{accessorParams}}); {{platformTrimmed}} {{access}}{{methodSpecForThis}}{{ret}} {{name}}({{parms}}) => {{body}} """); @@ -480,11 +485,15 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE """); if (isGenericEvent && !string.IsNullOrEmpty(eventSourceInteropType)) { - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.Constructor)] - [return: UnsafeAccessorType("{{eventSourceInteropType}}")] - static extern object ctor(WindowsRuntimeObjectReference nativeObjectReference, int index); - """); + writer.IncreaseIndent(); + writer.IncreaseIndent(); + UnsafeAccessorFactory.EmitConstructorReturningObject( + writer, + interopType: eventSourceInteropType, + functionName: "ctor", + parameterList: "WindowsRuntimeObjectReference nativeObjectReference, int index"); + writer.DecreaseIndent(); + writer.DecreaseIndent(); writer.WriteLine(); } writer.Write(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index c69757ee5..cc7740712 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -173,11 +173,14 @@ public override unsafe void Invoke( string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(p.Type, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, p.Type, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToUnmanaged")] - static extern WindowsRuntimeObjectReferenceValue ConvertToUnmanaged_{{raw}}([UnsafeAccessorType("{{interopTypeName}}")] object _, {{projectedTypeName}} value); - using WindowsRuntimeObjectReferenceValue __{{raw}} = ConvertToUnmanaged_{{raw}}(null, {{pname}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToUnmanaged", + returnType: "WindowsRuntimeObjectReferenceValue", + functionName: $"ConvertToUnmanaged_{raw}", + interopType: interopTypeName, + parameterList: $", {projectedTypeName.Format()} value"); + writer.WriteLine($"using WindowsRuntimeObjectReferenceValue __{raw} = ConvertToUnmanaged_{raw}(null, {pname});"); } // For runtime class / object params, emit `using WindowsRuntimeObjectReferenceValue __ = ...ConvertToUnmanaged();` @@ -465,11 +468,14 @@ public override unsafe void Invoke( else { WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "CopyToUnmanaged")] - static extern void CopyToUnmanaged_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, ReadOnlySpan<{{elementProjected}}> span, uint length, void** data); - CopyToUnmanaged_{{raw}}(null, {{pname}}, (uint){{pname}}.Length, (void**)_{{raw}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "CopyToUnmanaged", + returnType: "void", + functionName: $"CopyToUnmanaged_{raw}", + interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType), + parameterList: $", ReadOnlySpan<{elementProjected.Format()}> span, uint length, void** data"); + writer.WriteLine($"CopyToUnmanaged_{raw}(null, {pname}, (uint){pname}.Length, (void**)_{raw});"); } } @@ -636,10 +642,15 @@ public override unsafe void Invoke( else { writer.WriteLine(); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "Dispose", + returnType: "void", + functionName: $"Dispose_{raw}", + interopType: ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType), + parameterList: ", uint length, void** data"); + writer.WriteLine(); writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "Dispose")] - static extern void Dispose_{{raw}}([UnsafeAccessorType("{{ArrayElementEncoder.GetArrayMarshallerInteropPath(szArr.BaseType)}}")] object _, uint length, void** data); - fixed(void* _{{raw}} = {{names.Span}}) { Dispose_{{raw}}(null, (uint) {{names.Span}}.Length, (void**)_{{raw}}); diff --git a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs index 4fea935ee..2fe822f23 100644 --- a/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/EventTableFactory.cs @@ -80,11 +80,18 @@ internal static void EmitDoAbiAddEvent(IndentedTextWriter writer, ProjectionEmit { string interopTypeName = InteropTypeNameWriter.GetInteropAssemblyQualifiedName(evtTypeSig, TypedefNameType.ABI); WriteProjectedSignatureCallback projectedTypeName = MethodFactory.WriteProjectedSignature(context, evtTypeSig, false); - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "ConvertToManaged")] - static extern {{projectedTypeName}} ConvertToManaged([UnsafeAccessorType("{{interopTypeName}}")] object _, void* value); - var __handler = ConvertToManaged(null, {{handlerRef}}); - """); + writer.IncreaseIndent(); + writer.IncreaseIndent(); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: "ConvertToManaged", + returnType: projectedTypeName.Format(), + functionName: "ConvertToManaged", + interopType: interopTypeName, + parameterList: ", void* value"); + writer.WriteLine($"var __handler = ConvertToManaged(null, {handlerRef});"); + writer.DecreaseIndent(); + writer.DecreaseIndent(); } else { diff --git a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs index 9f10aea45..05ac96fba 100644 --- a/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MappedInterfaceStubFactory.cs @@ -384,10 +384,13 @@ private static void EmitList(IndentedTextWriter writer, ProjectionEmitContext co /// private static void EmitUnsafeAccessor(IndentedTextWriter writer, string accessName, string returnType, string functionName, string interopType, string extraParams) { - writer.WriteLine(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{accessName}}")] - static extern {{returnType}} {{functionName}}([UnsafeAccessorType("{{interopType}}")] object _, WindowsRuntimeObjectReference objRef{{extraParams}}); - """); + UnsafeAccessorFactory.EmitStaticMethod( + writer, + accessName: accessName, + returnType: returnType, + functionName: functionName, + interopType: interopType, + parameterList: $", WindowsRuntimeObjectReference objRef{extraParams}"); writer.WriteLine(); } diff --git a/src/WinRT.Projection.Writer/Factories/UnsafeAccessorFactory.cs b/src/WinRT.Projection.Writer/Factories/UnsafeAccessorFactory.cs new file mode 100644 index 000000000..4323b9f7f --- /dev/null +++ b/src/WinRT.Projection.Writer/Factories/UnsafeAccessorFactory.cs @@ -0,0 +1,115 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet.Signatures; +using WindowsRuntime.ProjectionWriter.Generation; +using WindowsRuntime.ProjectionWriter.Helpers; +using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Writers; + +namespace WindowsRuntime.ProjectionWriter.Factories; + +/// +/// Centralised emitters for [UnsafeAccessor] static extern declarations. Consolidates +/// the boilerplate around the attribute scaffolding so call sites only need to express the parts +/// that vary (access name, return type, function name, interop type, and parameter list). +/// +internal static class UnsafeAccessorFactory +{ + /// + /// Emits an [UnsafeAccessor(UnsafeAccessorKind.StaticMethod)] static extern declaration + /// targeting a static method on the type identified by : + /// + /// [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{accessName}")] + /// static extern {returnType} {functionName}([UnsafeAccessorType("{interopType}")] object _{parameterList}); + /// + /// + /// The writer to emit to. + /// The metadata name of the static method being accessed. + /// The C# return type of the accessor (as a syntax string). + /// The C# name of the accessor (i.e. the local extern method). + /// The assembly-qualified interop type the accessor punches into. + /// The trailing parameter list (after the object _ parameter), + /// including the leading comma when non-empty. Pass for the parameter-less form. + public static void EmitStaticMethod( + IndentedTextWriter writer, + string accessName, + string returnType, + string functionName, + string interopType, + string parameterList) + { + writer.WriteLine(isMultiline: true, $$""" + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "{{accessName}}")] + static extern {{returnType}} {{functionName}}([UnsafeAccessorType("{{interopType}}")] object _{{parameterList}}); + """); + } + + /// + /// Emits an [UnsafeAccessor(UnsafeAccessorKind.Constructor)] static extern declaration + /// whose return type is annotated with [return: UnsafeAccessorType("{interopType}")]: + /// + /// [UnsafeAccessor(UnsafeAccessorKind.Constructor)] + /// [return: UnsafeAccessorType("{interopType}")] + /// static extern object {functionName}({parameterList}); + /// + /// + /// The writer to emit to. + /// The assembly-qualified interop type whose constructor is being accessed. + /// The C# name of the constructor accessor (i.e. the local extern method). + /// The constructor's full parameter list (no leading comma). + public static void EmitConstructorReturningObject( + IndentedTextWriter writer, + string interopType, + string functionName, + string parameterList) + { + writer.WriteLine(isMultiline: true, $$""" + [UnsafeAccessor(UnsafeAccessorKind.Constructor)] + [return: UnsafeAccessorType("{{interopType}}")] + static extern object {{functionName}}({{parameterList}}); + """); + } + + /// + /// Emits the [UnsafeAccessor] extern method declaration that exposes the IID for a + /// generic interface instantiation. The declaration is written as a contiguous multi-line + /// chunk; on completion the writer's buffer ends with a newline. + /// + /// The writer to emit to. + /// The active emit context. + /// The generic interface instantiation whose IID accessor is being emitted. + /// When , the accessor's parameter type is + /// object? (used inside #nullable enable regions); otherwise object. + public static void EmitIidAccessor(IndentedTextWriter writer, ProjectionEmitContext context, GenericInstanceTypeSignature gi, bool isInNullableContext = false) + { + string propName = ObjRefNameGenerator.BuildIidPropertyNameForGenericInterface(context, gi); + string interopName = InteropTypeNameWriter.EncodeInteropTypeName(gi, TypedefNameType.InteropIID); + + writer.Write(isMultiline: true, $$""" + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "get_IID_{{interopName}}")] + static extern ref readonly Guid {{propName}}([UnsafeAccessorType("ABI.InterfaceIIDs, WinRT.Interop")] object + """); + + writer.WriteIf(isInNullableContext, "?"); + + writer.WriteLine(" _);"); + } + + /// + /// Convenience overload of + /// that leases an from , + /// emits the IID accessor declaration into it, and returns the resulting string. + /// + /// The active emit context. + /// The generic interface instantiation whose IID accessor is being emitted. + /// When , the accessor's parameter type is object?; otherwise object. + /// The emitted IID accessor declaration. + public static string EmitIidAccessor(ProjectionEmitContext context, GenericInstanceTypeSignature gi, bool isInNullableContext = false) + { + using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); + IndentedTextWriter writer = writerOwner.Writer; + EmitIidAccessor(writer, context, gi, isInNullableContext); + return writer.ToString(); + } +} diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 4f7731761..5ad48dfb9 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -207,44 +207,6 @@ internal static string BuildIidPropertyNameForGenericInterface(ProjectionEmitCon stripGlobal: true, stripGlobalABI: true); } - /// - /// Emits the [UnsafeAccessor] extern method declaration that exposes the IID for a generic - /// interface instantiation. - /// - /// The writer to emit to. - /// The active emit context. - /// The generic interface instantiation whose IID accessor is being emitted. - /// When true, the accessor's parameter type is - /// object? (used inside #nullable enable regions); otherwise object. - internal static void EmitUnsafeAccessorForIid(IndentedTextWriter writer, ProjectionEmitContext context, GenericInstanceTypeSignature gi, bool isInNullableContext = false) - { - string propName = BuildIidPropertyNameForGenericInterface(context, gi); - string interopName = InteropTypeNameWriter.EncodeInteropTypeName(gi, TypedefNameType.InteropIID); - writer.Write(isMultiline: true, $$""" - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "get_IID_{{interopName}}")] - static extern ref readonly Guid {{propName}}([UnsafeAccessorType("ABI.InterfaceIIDs, WinRT.Interop")] object - """); - writer.WriteIf(isInNullableContext, "?"); - - writer.WriteLine(" _);"); - } - - /// - /// Convenience overload of - /// that leases an from , - /// emits the [UnsafeAccessor] declaration into it, and returns the resulting string. - /// - /// The active emit context. - /// The generic interface instantiation whose IID accessor is being emitted. - /// When true, the accessor's parameter type is object?; otherwise object. - /// The emitted [UnsafeAccessor] declaration. - internal static string EmitUnsafeAccessorForIid(ProjectionEmitContext context, GenericInstanceTypeSignature gi, bool isInNullableContext = false) - { - using IndentedTextWriterOwner writerOwner = IndentedTextWriterPool.GetOrCreate(); - IndentedTextWriter writer = writerOwner.Writer; - EmitUnsafeAccessorForIid(writer, context, gi, isInNullableContext); - return writer.ToString(); - } private static string EscapeIdentifier(string s) { System.Text.StringBuilder sb = new(s.Length); @@ -390,7 +352,7 @@ private static void EmitObjRefForInterface(IndentedTextWriter writer, Projection // constructor for the default interface. if (gi is not null) { - EmitUnsafeAccessorForIid(writer, context, gi); + UnsafeAccessorFactory.EmitIidAccessor(writer, context, gi); } } else @@ -398,7 +360,7 @@ private static void EmitObjRefForInterface(IndentedTextWriter writer, Projection // Emit the unsafe accessor BEFORE the lazy field so it's referenced inside the As(...) call. if (gi is not null) { - EmitUnsafeAccessorForIid(writer, context, gi); + UnsafeAccessorFactory.EmitIidAccessor(writer, context, gi); } // Lazy CompareExchange pattern. For unsealed-class defaults, also emit 'init;' so the From eaf64b9840b79212e974b7fdbd019f96969925f5 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:55:49 -0700 Subject: [PATCH 141/171] Strip backticks inside BuildGlobalQualifiedName Pushes the IdentifierEscaping.StripBackticks(name) call inside BuildGlobalQualifiedName so that callers don't have to remember to strip the generic-arity suffix before building a global-qualified name (there's no reason a global::Ns.Name expression should ever embed a backtick suffix). StripBackticks is idempotent on already-stripped names, so the change is safe for the existing callers that pass the result of GetStrippedName() (which already strips). Five callers that explicitly wrapped IdentifierEscaping.StripBackticks(...) around the name argument are simplified to pass the raw name: * ClassMembersFactory.cs (2) * ComponentFactory.cs (1) * MetadataAttributeFactory.cs (2) The XML docs are updated to reflect the new contract. Build clean (0 warnings, 0 errors). Validate-All reports 0 diffs across pushnot, everything-with-ui, and windows scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/ClassMembersFactory.cs | 4 ++-- src/WinRT.Projection.Writer/Factories/ComponentFactory.cs | 2 +- .../Factories/MetadataAttributeFactory.cs | 4 ++-- src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs | 7 +++++-- 4 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index c8f101f55..8c0c3e0e1 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -111,7 +111,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro (string ns, string name) = tr.Names(); _ = MappedTypes.ApplyMapping(ref ns, ref name); - writer.Write(TypedefNameWriter.BuildGlobalQualifiedName(ns, IdentifierEscaping.StripBackticks(name))); + writer.Write(TypedefNameWriter.BuildGlobalQualifiedName(ns, name)); } else if (ifaceType.TryGetGenericInstance(out GenericInstanceTypeSignature? gi)) { @@ -119,7 +119,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro (string ns, string name) = gt.Names(); _ = MappedTypes.ApplyMapping(ref ns, ref name); - writer.Write($"{TypedefNameWriter.BuildGlobalQualifiedName(ns, IdentifierEscaping.StripBackticks(name))}<"); + writer.Write($"{TypedefNameWriter.BuildGlobalQualifiedName(ns, name)}<"); for (int i = 0; i < gi.TypeArguments.Count; i++) { writer.WriteIf(i > 0, ", "); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index afb6b9dab..1df47cea2 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -51,7 +51,7 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo { string typeName = type.Name?.Value ?? string.Empty; string typeNs = type.Namespace?.Value ?? string.Empty; - string projectedTypeName = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, IdentifierEscaping.StripBackticks(typeName)); + string projectedTypeName = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, typeName); string factoryTypeName = $"{IdentifierEscaping.StripBackticks(typeName)}ServerActivationFactory"; bool isActivatable = !TypeCategorization.IsStatic(type) && type.HasDefaultConstructor(); diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index fcb4b9758..5736993a8 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -423,7 +423,7 @@ public static void AddDefaultInterfaceEntry(ProjectionEmitContext context, TypeD } (string typeNs, string typeName) = type.Names(); - string className = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, IdentifierEscaping.StripBackticks(typeName)); + string className = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, typeName); // Resolve TypeReference -> TypeDefinition so WriteTypeName goes through the Definition // branch which knows about authored-type CCW namespacing (ABI.Impl. prefix). @@ -457,7 +457,7 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, } (string typeNs, string typeName) = type.Names(); - string className = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, IdentifierEscaping.StripBackticks(typeName)); + string className = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, typeName); foreach (InterfaceImplementation impl in type.Interfaces) { diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 41c468cd2..209032256 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -20,13 +20,16 @@ internal static class TypedefNameWriter { /// /// Builds the fully-qualified global::Ns.Name form for a type, handling the empty-namespace case. + /// The is run through + /// so callers may pass either a raw metadata name (e.g. "IList`1") or an already-stripped name. /// /// The type's namespace (may be or empty for top-level types). - /// The type's name (already stripped of backticks if applicable). + /// The type's name (raw or already stripped; a generic-arity backtick suffix is stripped before use). /// The string global::Name when is null/empty, otherwise global::Ns.Name. public static string BuildGlobalQualifiedName(string? ns, string name) { - return string.IsNullOrEmpty(ns) ? $"global::{name}" : $"global::{ns}.{name}"; + string stripped = IdentifierEscaping.StripBackticks(name); + return string.IsNullOrEmpty(ns) ? $"global::{stripped}" : $"global::{ns}.{stripped}"; } /// From a9f04348eda31303892b32b7e2129fb124fba55c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 11:56:47 -0700 Subject: [PATCH 142/171] Rename ParameterCategory.IsByValue() to IsScalarInput() The previous name was misleading: ParameterCategory.Ref is conceptually an 'in T' parameter on the WinRT ABI side, but at the IL level it is genuinely passed by reference (not by value). The new name describes what the predicate actually captures - non-array input parameters that the callee reads, regardless of whether the underlying transport is by-value or by-reference - and pairs naturally with the existing IsArrayInput() helper on the same extension. The XML doc is also updated to mention the IsArrayInput pairing. Build clean (0 warnings, 0 errors). Validate-All reports 0 diffs across pushnot, everything-with-ui, and windows scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/ParameterCategoryExtensions.cs | 7 ++++--- .../Factories/AbiMethodBodyFactory.RcwCaller.cs | 6 +++--- .../Models/MethodSignatureMarshallingFacts.cs | 2 +- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs index 4b50054fc..076c70595 100644 --- a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs @@ -23,11 +23,12 @@ public bool IsArrayInput() } /// - /// Returns whether the input category is a scalar by-value parameter that the callee + /// Returns whether the input category is a non-array input parameter that the callee /// reads ( or ) — - /// i.e. not an array, not an output parameter, and not a receive-array. + /// i.e. not an array, not an output parameter, and not a receive-array. This is the + /// natural complement of on the input side of the boundary. /// - public bool IsByValue() + public bool IsScalarInput() { return category is ParameterCategory.In or ParameterCategory.Ref; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index e7fe959d9..0106e5d8e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -294,7 +294,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (!cat.IsByValue()) + if (!cat.IsScalarInput()) { continue; } @@ -460,7 +460,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (!cat.IsByValue()) + if (!cat.IsScalarInput()) { continue; } @@ -1146,7 +1146,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec ParameterInfo p = sig.Parameters[i]; ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); - if (!cat.IsByValue()) + if (!cat.IsScalarInput()) { continue; } diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index 504360b6a..3a8b35f66 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -99,7 +99,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT hasNonBlittablePassArray = true; } - if (!hasComplexStructInput && cat.IsByValue() + if (!hasComplexStructInput && cat.IsScalarInput() && resolver.IsComplexStruct(p.Type.StripByRefAndCustomModifiers())) { hasComplexStructInput = true; From f8c64457f59203540f1ed92d257096f45d08c50c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 12:58:28 -0700 Subject: [PATCH 143/171] Extract MethodSignatureMarshallingFacts composite checks to resolver helpers The From method had three composite ABI-shape conditions inline that re-derived their meaning from low-level resolver primitives at the call site. Each one captured a concrete piece of WinRT-marshalling business logic that's worth a named predicate on AbiTypeShapeResolver (alongside the existing IsBlittableAbiElement helper which follows the same pattern): * IsRecognizedReceiveArrayElement(TypeSignature) -- the 5-way union of element shapes the receive-array paths can marshal (blittable element, ref-like, complex struct, HResult exception, mapped value type). Replaces the inline disjunction used to derive ReturnIsReceiveArray. * RequiresOutParameterCleanup(TypeSignature) -- the 4-way predicate that detects Out-parameter types holding a resource that needs finally-block cleanup (ref-like array element, System.Type, complex struct, generic instance). Replaces the inline disjunction used to derive HasOutNeedsCleanup. Takes the stripped (non-byref) type. * IsDirectPassArrayElement(TypeSignature) -- the 2-way union of array-element shapes that flow across the ABI without per-element marshalling (blittable element or mapped value type). Removes the double-negation at the HasNonBlittablePassArray call site, which now reads as '!resolver.IsDirectPassArrayElement(...)'. Each helper carries detailed XML docs that enumerate the matched shapes, link back to the underlying primitive predicates, and call out the semantic intent (when the predicate fires and what it gates). None of the composite checks were duplicated elsewhere -- this is a readability / encapsulation pass, not a dedup pass. Note that DoAbi has a similar but semantically narrower 3-way receive-array check (missing HResultException and MappedAbiValueType); that check is left untouched because mapping it onto the new 5-way helper would silently widen the gated behaviour. Build clean (0 warnings, 0 errors). Validate-All reports 0 diffs across pushnot, everything-with-ui, and windows scenarios. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Models/MethodSignatureMarshallingFacts.cs | 19 ++----- .../Resolvers/AbiTypeShapeResolver.cs | 55 +++++++++++++++++++ 2 files changed, 60 insertions(+), 14 deletions(-) diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index 3a8b35f66..52a2985d5 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -61,11 +61,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT bool returnIsBlittableStruct = returnShape == AbiTypeShapeKind.BlittableStruct; bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; bool returnIsReceiveArray = rt is SzArrayTypeSignature retSz - && (resolver.IsBlittableAbiElement(retSz.BaseType) - || retSz.BaseType.IsAbiArrayElementRefLike(resolver) - || resolver.IsComplexStruct(retSz.BaseType) - || retSz.BaseType.IsHResultException() - || resolver.IsMappedAbiValueType(retSz.BaseType)); + && resolver.IsRecognizedReceiveArrayElement(retSz.BaseType); bool returnIsHResultException = returnShape == AbiTypeShapeKind.HResultException; bool returnIsSystemTypeForCleanup = rt is not null && rt.IsSystemType(); @@ -76,14 +72,10 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT foreach ((_, ParameterInfo p, ParameterCategory cat) in sig.EnumerateWithCategory()) { - if (!hasOutNeedsCleanup && cat == ParameterCategory.Out) + if (!hasOutNeedsCleanup && cat == ParameterCategory.Out + && resolver.RequiresOutParameterCleanup(p.Type.StripByRefAndCustomModifiers())) { - TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); - - if (uOut.IsAbiArrayElementRefLike(resolver) || uOut.IsSystemType() || resolver.IsComplexStruct(uOut) || uOut.IsGenericInstance()) - { - hasOutNeedsCleanup = true; - } + hasOutNeedsCleanup = true; } if (!hasReceiveArray && cat == ParameterCategory.ReceiveArray) @@ -93,8 +85,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT if (!hasNonBlittablePassArray && cat.IsArrayInput() && p.Type is SzArrayTypeSignature szArr - && !resolver.IsBlittableAbiElement(szArr.BaseType) - && !resolver.IsMappedAbiValueType(szArr.BaseType)) + && !resolver.IsDirectPassArrayElement(szArr.BaseType)) { hasNonBlittablePassArray = true; } diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs index 3a8ab3c5b..343deeb4d 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs @@ -121,6 +121,61 @@ public bool IsMappedAbiValueType(TypeSignature signature) public bool IsBlittableAbiElement(TypeSignature signature) => IsBlittablePrimitive(signature) || IsBlittableStruct(signature); + /// + /// Returns whether is an SZ-array element shape that flows across the + /// ABI without per-element marshalling — either a blittable element (blittable primitive or + /// blittable struct, see ) or a mapped value type (e.g. + /// WinRT DateTime -> , see ). + /// Used to gate "do we need to walk each element on input?" decisions in the array-pass paths. + /// + /// The element type to classify. + /// when the element can pass directly; otherwise . + public bool IsDirectPassArrayElement(TypeSignature signature) + => IsBlittableAbiElement(signature) || IsMappedAbiValueType(signature); + + /// + /// Returns whether is a recognised SZ-array element shape for which + /// the projection has an ABI marshalling story. This is the union of all five concrete element + /// shapes that the receive-array paths know how to handle: + /// + /// Blittable element (primitive or blittable struct) — see + /// Ref-like (string / runtime class / interface / object) — see + /// Complex struct — see + /// (mapped from WinRT HResult) — see + /// Mapped value type (e.g. WinRT DateTime / TimeSpan) — see + /// + /// Element types outside this set (e.g. generic instances, , unresolved + /// references) cannot be returned as a receive-array. + /// + /// The element type to classify. + /// when the element is one of the recognised receive-array shapes; otherwise . + public bool IsRecognizedReceiveArrayElement(TypeSignature signature) + => IsBlittableAbiElement(signature) + || signature.IsAbiArrayElementRefLike(this) + || IsComplexStruct(signature) + || signature.IsHResultException() + || IsMappedAbiValueType(signature); + + /// + /// Returns whether identifies a parameter type that, when received + /// via an Out parameter, holds a resource which the caller must release in a finally + /// block. This includes: + /// + /// SZ-array element ref-like types (HSTRING / IInspectable* slots) — see + /// (whose ABI form is an HSTRING that must be freed) — see + /// Complex structs (per-field cleanup via the *Marshaller) — see + /// Generic instances (need WindowsRuntimeObjectReferenceValue dispose) — see + /// + /// Callers should pass the already-stripped parameter type (via ). + /// + /// The stripped (non-byref) parameter type to classify. + /// when the type requires finally-block cleanup on receive; otherwise . + public bool RequiresOutParameterCleanup(TypeSignature signature) + => signature.IsAbiArrayElementRefLike(this) + || signature.IsSystemType() + || IsComplexStruct(signature) + || signature.IsGenericInstance(); + /// /// Classifies into one of the six /// values used by the per-element pointer-type ladders. From 9ade706a4c61d790914ca22a154102e9000009ee Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 13:07:05 -0700 Subject: [PATCH 144/171] Simplify AbiTypeKindResolver: drop AbiTypeShape wrapper and rename to AbiType* MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per follow-up: the AbiTypeShape record was used only by callers immediately reading its .Kind property — the .Signature member was never accessed, and the caller already had the signature at the call site, so the wrapper added zero value. Changes: - Rename AbiTypeShapeKind → AbiTypeKind (enum) - Rename AbiTypeShapeResolver → AbiTypeKindResolver (class + property) - Rename AbiTypeShapeKindExtensions → AbiTypeKindExtensions - Delete the AbiTypeShape record (truly unused wrapper) - AbiTypeKindResolver.Resolve now returns AbiTypeKind directly - Drop the now-redundant .Kind accessor from all call sites Pure rename + signature simplification — generated projection output remains byte-identical across all 3 regen scenarios (0 diffs). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- ...Extensions.cs => AbiTypeKindExtensions.cs} | 16 ++-- .../Extensions/TypeSignatureExtensions.cs | 10 +-- .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 48 +++++------ .../AbiMethodBodyFactory.RcwCaller.cs | 84 +++++++++---------- .../Factories/AbiStructFactory.cs | 2 +- .../ConstructorFactory.FactoryCallbacks.cs | 18 ++-- .../Factories/StructEnumMarshallerFactory.cs | 8 +- .../Generation/ProjectionEmitContext.cs | 2 +- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 12 +-- .../Helpers/AbiTypeWriter.cs | 4 +- .../{AbiTypeShapeKind.cs => AbiTypeKind.cs} | 2 +- .../Models/AbiTypeShape.cs | 14 ---- .../Models/MethodSignatureMarshallingFacts.cs | 18 ++-- ...hapeResolver.cs => AbiTypeKindResolver.cs} | 61 +++++++------- 15 files changed, 143 insertions(+), 158 deletions(-) rename src/WinRT.Projection.Writer/Extensions/{AbiTypeShapeKindExtensions.cs => AbiTypeKindExtensions.cs} (62%) rename src/WinRT.Projection.Writer/Models/{AbiTypeShapeKind.cs => AbiTypeKind.cs} (98%) delete mode 100644 src/WinRT.Projection.Writer/Models/AbiTypeShape.cs rename src/WinRT.Projection.Writer/Resolvers/{AbiTypeShapeResolver.cs => AbiTypeKindResolver.cs} (87%) diff --git a/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs b/src/WinRT.Projection.Writer/Extensions/AbiTypeKindExtensions.cs similarity index 62% rename from src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs rename to src/WinRT.Projection.Writer/Extensions/AbiTypeKindExtensions.cs index 8c8d668d6..2c0f06aa1 100644 --- a/src/WinRT.Projection.Writer/Extensions/AbiTypeShapeKindExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/AbiTypeKindExtensions.cs @@ -6,12 +6,12 @@ namespace WindowsRuntime.ProjectionWriter; /// -/// Extension methods for . +/// Extension methods for . /// -internal static class AbiTypeShapeKindExtensions +internal static class AbiTypeKindExtensions { /// The input ABI type kind. - extension(AbiTypeShapeKind kind) + extension(AbiTypeKind kind) { /// /// Returns whether the shape is a reference-type marshalling kind: Windows Runtime classes/interfaces, @@ -20,11 +20,11 @@ internal static class AbiTypeShapeKindExtensions /// public bool IsReferenceType() { - return kind is AbiTypeShapeKind.RuntimeClassOrInterface - or AbiTypeShapeKind.Delegate - or AbiTypeShapeKind.Object - or AbiTypeShapeKind.GenericInstance - or AbiTypeShapeKind.NullableT; + return kind is AbiTypeKind.RuntimeClassOrInterface + or AbiTypeKind.Delegate + or AbiTypeKind.Object + or AbiTypeKind.GenericInstance + or AbiTypeKind.NullableT; } } } diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 0ef3c9a75..f9098fac0 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -17,7 +17,7 @@ namespace WindowsRuntime.ProjectionWriter; /// /// Predicates that need cross-module type resolution (e.g. IsBlittablePrimitive /// with cross-module enum lookup, IsAnyStruct, IsComplexStruct) live in -/// and the ; +/// and the ; /// they are intentionally not included here. /// internal static class TypeSignatureExtensions @@ -117,13 +117,13 @@ public bool IsGenericInstance() /// any WinRT runtime class or interface (resolved via ), /// , and any generic instance (e.g. IList<T>). /// - /// The active (needed for runtime-class/interface resolution). + /// The active (needed for runtime-class/interface resolution). /// if the signature flows as a void* across the ABI; otherwise . /// /// Use this variant for parameter/return types. For SZ-array element types (where generic /// instances cannot appear as elements), use instead. /// - public bool IsAbiRefLike(AbiTypeShapeResolver resolver) + public bool IsAbiRefLike(AbiTypeKindResolver resolver) { return sig.IsString() || @@ -140,9 +140,9 @@ public bool IsAbiRefLike(AbiTypeShapeResolver resolver) /// without the IsGenericInstance case, because generic instances cannot /// appear as array elements in metadata. /// - /// The active (needed for runtime-class/interface resolution). + /// The active (needed for runtime-class/interface resolution). /// if the signature flows as a void* when used as an SZ-array element; otherwise . - public bool IsAbiArrayElementRefLike(AbiTypeShapeResolver resolver) + public bool IsAbiArrayElementRefLike(AbiTypeKindResolver resolver) { return sig.IsString() || diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 7408a3841..e1edae895 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -98,7 +98,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj // Special case: 'out T[]' is a ReceiveArray ABI signature: (uint* size, T** data). if (br.BaseType is SzArrayTypeSignature brSz && cat == ParameterCategory.ReceiveArray) { - bool isRefElemBr = brSz.BaseType.IsAbiRefLike(context.AbiTypeShapeResolver); + bool isRefElemBr = brSz.BaseType.IsAbiRefLike(context.AbiTypeKindResolver); WriteAbiTypeCallback elemAbi = AbiTypeWriter.WriteAbiType(context, TypeSemanticsFactory.Get(brSz.BaseType)); if (includeParamNames) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 7c120c3df..8edf90cbb 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -26,14 +26,14 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection TypeSignature? rt = sig.ReturnType; bool returnIsReceiveArrayDoAbi = rt is SzArrayTypeSignature retSzAbi - && (context.AbiTypeShapeResolver.IsBlittableAbiElement(retSzAbi.BaseType) - || retSzAbi.BaseType.IsAbiArrayElementRefLike(context.AbiTypeShapeResolver) - || context.AbiTypeShapeResolver.IsComplexStruct(retSzAbi.BaseType)); + && (context.AbiTypeKindResolver.IsBlittableAbiElement(retSzAbi.BaseType) + || retSzAbi.BaseType.IsAbiArrayElementRefLike(context.AbiTypeKindResolver) + || context.AbiTypeKindResolver.IsComplexStruct(retSzAbi.BaseType)); bool returnIsHResultExceptionDoAbi = rt is not null && rt.IsHResultException(); bool returnIsString = rt is not null && rt.IsString(); - bool returnIsRefType = rt is not null && context.AbiTypeShapeResolver.IsReferenceTypeOrGenericInstance(rt); + bool returnIsRefType = rt is not null && context.AbiTypeKindResolver.IsReferenceTypeOrGenericInstance(rt); bool returnIsGenericInstance = rt is not null && rt.IsGenericInstance(); - bool returnIsBlittableStruct = rt is not null && context.AbiTypeShapeResolver.IsBlittableStruct(rt); + bool returnIsBlittableStruct = rt is not null && context.AbiTypeKindResolver.IsBlittableStruct(rt); bool isGetter = sig.Method.IsGetter; bool isSetter = sig.Method.IsSetter; @@ -238,7 +238,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string raw = p.GetRawName(); string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(sz.BaseType)); - bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(sz.BaseType); + bool isBlittableElem = context.AbiTypeKindResolver.IsBlittableAbiElement(sz.BaseType); if (isBlittableElem) { @@ -275,7 +275,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -291,7 +291,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string dataParamType; string dataCastExpr; - if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsComplexStruct(szArr.BaseType)) { string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); dataParamType = abiStructName + "* data"; @@ -410,11 +410,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { writer.Write($"WindowsRuntimeObjectMarshaller.ConvertToManaged(*{ptr})"); } - else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uRef)) + else if (context.AbiTypeKindResolver.IsRuntimeClassOrInterface(uRef)) { writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uRef)}.ConvertToManaged(*{ptr})"); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(uRef)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(uRef)) { writer.Write($"{AbiTypeHelpers.GetMappedMarshallerName(uRef)}.ConvertToManaged(*{ptr})"); } @@ -422,11 +422,11 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { writer.Write($"global::ABI.System.ExceptionMarshaller.ConvertToManaged(*{ptr})"); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(uRef)) + else if (context.AbiTypeKindResolver.IsComplexStruct(uRef)) { writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uRef)}.ConvertToManaged(*{ptr})"); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(uRef) || context.AbiTypeShapeResolver.IsBlittablePrimitive(uRef) || context.AbiTypeShapeResolver.IsEnumType(uRef)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(uRef) || context.AbiTypeKindResolver.IsBlittablePrimitive(uRef) || context.AbiTypeKindResolver.IsEnumType(uRef)) { // Blittable/almost-blittable: ABI layout matches projected layout. writer.Write($"*{ptr}"); @@ -475,7 +475,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { rhs = $"WindowsRuntimeObjectMarshaller.ConvertToUnmanaged(__{raw}).DetachThisPtrUnsafe()"; } - else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(underlying)) + else if (context.AbiTypeKindResolver.IsRuntimeClassOrInterface(underlying)) { rhs = $"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw}).DetachThisPtrUnsafe()"; } @@ -496,7 +496,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // the local managed value through Marshaller.ConvertToUnmanaged before // writing it into the *out ABI struct slot.write_marshal_from_managed //: "Marshaller.ConvertToUnmanaged(local)". - else if (context.AbiTypeShapeResolver.IsComplexStruct(underlying)) + else if (context.AbiTypeKindResolver.IsComplexStruct(underlying)) { rhs = $"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw})"; } @@ -532,7 +532,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } // Blittable element types: Span wraps the native buffer; no copy-back needed. - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szFA.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szFA.BaseType)) { continue; } @@ -591,7 +591,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // was hoisted to the top of the method body). writer.WriteLine($"ConvertToUnmanaged_{retParamName}(null, {retLocalName}, out *{retSizeParamName}, out *{retParamName});"); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(rt)) { // Mapped value type return (DateTime/TimeSpan): convert via marshaller. writer.WriteLine($"*{retParamName} = {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToUnmanaged({retLocalName});"); @@ -601,7 +601,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // System.Type return (server-side): convert managed System.Type to ABI Type struct. writer.WriteLine($"*{retParamName} = global::ABI.System.TypeMarshaller.ConvertToUnmanaged({retLocalName});"); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(rt)) + else if (context.AbiTypeKindResolver.IsComplexStruct(rt)) { // Complex struct return (server-side): convert managed struct to ABI struct via marshaller. writer.WriteLine($"*{retParamName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt)}.ConvertToUnmanaged({retLocalName});"); @@ -643,7 +643,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -674,7 +674,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -725,11 +725,11 @@ internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, Proj // local var __arg_ that holds the converted value. writer.Write($"__arg_{rawName}"); } - else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject()) + else if (context.AbiTypeKindResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject()) { EmitMarshallerConvertToManaged(writer, context, p.Type, pname); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(p.Type)) { // Mapped value type input (DateTime/TimeSpan): the parameter is the ABI type; // convert to the projected managed type via the marshaller. @@ -740,17 +740,17 @@ internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, Proj // System.Type input (server-side): convert ABI Type struct to System.Type. writer.Write($"global::ABI.System.TypeMarshaller.ConvertToManaged({pname})"); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsComplexStruct(p.Type)) { // Complex struct input (server-side): convert ABI struct to managed via marshaller. writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, p.Type)}.ConvertToManaged({pname})"); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(p.Type)) { // Blittable / almost-blittable struct: pass directly (projected type == ABI type). writer.Write(pname); } - else if (context.AbiTypeShapeResolver.IsEnumType(p.Type)) + else if (context.AbiTypeKindResolver.IsEnumType(p.Type)) { // Enum: param signature is already the projected enum type, no cast needed. writer.Write(pname); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 0106e5d8e..058abe20d 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -39,7 +39,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { TypeSignature? rt = sig.ReturnType; - MethodSignatureMarshallingFacts facts = MethodSignatureMarshallingFacts.From(sig, context.AbiTypeShapeResolver); + MethodSignatureMarshallingFacts facts = MethodSignatureMarshallingFacts.From(sig, context.AbiTypeKindResolver); bool returnIsString = facts.ReturnIsString; bool returnIsRefType = facts.ReturnIsRefType; @@ -66,7 +66,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uOut = p.Type.StripByRefAndCustomModifiers(); _ = fp.Append(", "); - if (uOut.IsAbiRefLike(context.AbiTypeShapeResolver)) + if (uOut.IsAbiRefLike(context.AbiTypeKindResolver)) { _ = fp.Append("void**"); } @@ -74,11 +74,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append(WellKnownAbiTypeNames.AbiSystemTypePointer); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) + else if (context.AbiTypeKindResolver.IsComplexStruct(uOut)) { _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, uOut)); _ = fp.Append('*'); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(uOut)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(uOut)) { _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, uOut)); _ = fp.Append('*'); } @@ -95,11 +95,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uRef = p.Type.StripByRefAndCustomModifiers(); _ = fp.Append(", "); - if (context.AbiTypeShapeResolver.IsComplexStruct(uRef)) + if (context.AbiTypeKindResolver.IsComplexStruct(uRef)) { _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, uRef)); _ = fp.Append('*'); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(uRef)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(uRef)) { _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, uRef)); _ = fp.Append('*'); } @@ -126,7 +126,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append(WellKnownAbiTypeNames.AbiSystemException); } - else if (p.Type.IsAbiRefLike(context.AbiTypeShapeResolver)) + else if (p.Type.IsAbiRefLike(context.AbiTypeKindResolver)) { _ = fp.Append("void*"); } @@ -134,17 +134,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append(WellKnownAbiTypeNames.AbiSystemType); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(p.Type)) { _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, p.Type)); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(p.Type)) { _ = fp.Append(AbiTypeHelpers.GetMappedAbiTypeName(p.Type)); } else { - _ = fp.Append(context.AbiTypeShapeResolver.IsComplexStruct(p.Type) + _ = fp.Append(context.AbiTypeKindResolver.IsComplexStruct(p.Type) ? AbiTypeHelpers.GetAbiStructTypeName(context, p.Type) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, p.Type)); } @@ -183,7 +183,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, rt!)); _ = fp.Append('*'); } - else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) + else if (rt is not null && context.AbiTypeKindResolver.IsMappedAbiValueType(rt)) { _ = fp.Append(AbiTypeHelpers.GetMappedAbiTypeName(rt)); _ = fp.Append('*'); } @@ -210,7 +210,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { ParameterInfo p = sig.Parameters[i]; - if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject()) + if (context.AbiTypeKindResolver.IsRuntimeClassOrInterface(p.Type) || p.Type.IsObject()) { string localName = p.GetParamLocalName(paramNameOverride); string callName = p.GetParamName(paramNameOverride); @@ -275,7 +275,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (!context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) + if (!context.AbiTypeKindResolver.IsMappedAbiValueType(p.Type)) { continue; } @@ -301,7 +301,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); - if (!context.AbiTypeShapeResolver.IsComplexStruct(pType)) + if (!context.AbiTypeKindResolver.IsComplexStruct(pType)) { continue; } @@ -355,7 +355,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -423,7 +423,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine($"{AbiTypeHelpers.GetAbiStructTypeName(context, rt!)} __retval = default;"); } - else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) + else if (rt is not null && context.AbiTypeKindResolver.IsMappedAbiValueType(rt)) { // Mapped value type return (e.g. DateTime/TimeSpan): use the ABI struct as __retval. writer.WriteLine($"{AbiTypeHelpers.GetMappedAbiTypeName(rt)} __retval = default;"); @@ -467,7 +467,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); - if (!context.AbiTypeShapeResolver.IsComplexStruct(pType)) + if (!context.AbiTypeKindResolver.IsComplexStruct(pType)) { continue; } @@ -545,7 +545,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { TypeSignature uRefSkip = p.Type.StripByRefAndCustomModifiers(); - if (context.AbiTypeShapeResolver.IsComplexStruct(uRefSkip)) + if (context.AbiTypeKindResolver.IsComplexStruct(uRefSkip)) { continue; } @@ -553,7 +553,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string callName = p.GetParamName(paramNameOverride); string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRef = uRefSkip; - string abiType = context.AbiTypeShapeResolver.IsBlittableStruct(uRef) ? AbiTypeHelpers.GetBlittableStructAbiType(context, uRef) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uRef); + string abiType = context.AbiTypeKindResolver.IsBlittableStruct(uRef) ? AbiTypeHelpers.GetBlittableStructAbiType(context, uRef) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, uRef); writer.WriteLine($"fixed({abiType}* _{localName} = &{callName})"); typedFixedCount++; } @@ -596,7 +596,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec else if (isPassArray) { TypeSignature elemT = ((SzArrayTypeSignature)p.Type).BaseType; - bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(elemT); + bool isBlittableElem = context.AbiTypeKindResolver.IsBlittableAbiElement(elemT); bool isStringElem = elemT.IsString(); if (isBlittableElem) @@ -673,7 +673,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -720,7 +720,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string dataParamType; string dataCastType; - if (context.AbiTypeShapeResolver.IsMappedAbiValueType(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsMappedAbiValueType(szArr.BaseType)) { dataParamType = AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) + "*"; dataCastType = "(" + AbiTypeHelpers.GetMappedAbiTypeName(szArr.BaseType) + "*)"; @@ -730,7 +730,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointer; dataCastType = "(global::ABI.System.Exception*)"; } - else if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) + else if (context.AbiTypeKindResolver.IsComplexStruct(szArr.BaseType)) { string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); dataParamType = abiStructName + "*"; @@ -805,7 +805,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRefArg = p.Type.StripByRefAndCustomModifiers(); - if (context.AbiTypeShapeResolver.IsComplexStruct(uRefArg)) + if (context.AbiTypeKindResolver.IsComplexStruct(uRefArg)) { // Complex struct 'in' (Ref) param: pass &__local (the marshaled ABI struct). writer.Write(isMultiline: true, $$""" @@ -835,7 +835,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.HString"); } - else if (context.AbiTypeShapeResolver.IsReferenceTypeOrGenericInstance(p.Type)) + else if (context.AbiTypeKindResolver.IsReferenceTypeOrGenericInstance(p.Type)) { writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.GetThisPtrUnsafe()"); } @@ -844,17 +844,17 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // System.Type input: pass the pre-converted ABI Type struct (via the local set up before the call). writer.Write($"__{p.GetParamLocalName(paramNameOverride)}.ConvertToUnmanagedUnsafe()"); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(p.Type)) { // Mapped value-type input: pass the pre-converted ABI local. writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsComplexStruct(p.Type)) { // Complex struct input: pass the pre-converted ABI struct local. writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(p.Type)) { writer.Write(p.GetParamName(paramNameOverride)); } @@ -898,7 +898,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szFA.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szFA.BaseType)) { continue; } @@ -960,7 +960,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.Write($"WindowsRuntimeObjectMarshaller.ConvertToManaged(__{localName})"); } - else if (context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uOut)) + else if (context.AbiTypeKindResolver.IsRuntimeClassOrInterface(uOut)) { writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.ConvertToManaged(__{localName})"); } @@ -968,11 +968,11 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.Write($"global::ABI.System.TypeMarshaller.ConvertToManaged(__{localName})"); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) + else if (context.AbiTypeKindResolver.IsComplexStruct(uOut)) { writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.ConvertToManaged(__{localName})"); } - else if (context.AbiTypeShapeResolver.IsBlittableStruct(uOut)) + else if (context.AbiTypeKindResolver.IsBlittableStruct(uOut)) { writer.Write($"__{localName}"); } @@ -984,7 +984,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.Write($"__{localName}"); } - else if (context.AbiTypeShapeResolver.IsEnumType(uOut)) + else if (context.AbiTypeKindResolver.IsEnumType(uOut)) { // Enum out param: __ local is already the projected enum type (since the // function pointer signature uses the projected type). No cast needed. @@ -1074,7 +1074,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.WriteLine($"return {cvt};"); } } - else if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) + else if (rt is not null && context.AbiTypeKindResolver.IsMappedAbiValueType(rt)) { // Mapped value type return (e.g. DateTime/TimeSpan): convert ABI struct back via marshaller. writer.WriteLine($"return {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToManaged(__retval);"); @@ -1086,7 +1086,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else if (returnIsBlittableStruct) { - if (rt is not null && context.AbiTypeShapeResolver.IsMappedAbiValueType(rt)) + if (rt is not null && context.AbiTypeKindResolver.IsMappedAbiValueType(rt)) { // Mapped value type return: convert ABI struct back to projected via marshaller. writer.WriteLine($"return {AbiTypeHelpers.GetMappedMarshallerName(rt)}.ConvertToManaged(__retval);"); @@ -1153,7 +1153,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); - if (!context.AbiTypeShapeResolver.IsComplexStruct(pType)) + if (!context.AbiTypeKindResolver.IsComplexStruct(pType)) { continue; } @@ -1182,12 +1182,12 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } - if (context.AbiTypeShapeResolver.IsMappedAbiValueType(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsMappedAbiValueType(szArr.BaseType)) { continue; } @@ -1252,7 +1252,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string fixedPtrType; string disposeCastType; - if (context.AbiTypeShapeResolver.IsComplexStruct(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsComplexStruct(szArr.BaseType)) { string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); disposeDataParamType = abiStructName + "*"; @@ -1306,7 +1306,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine($"HStringMarshaller.Free(__{localName});"); } - else if (uOut.IsObject() || context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(uOut) || uOut.IsGenericInstance()) + else if (uOut.IsObject() || context.AbiTypeKindResolver.IsRuntimeClassOrInterface(uOut) || uOut.IsGenericInstance()) { writer.WriteLine($"WindowsRuntimeUnknownMarshaller.Free(__{localName});"); } @@ -1314,7 +1314,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine($"global::ABI.System.TypeMarshaller.Dispose(__{localName});"); } - else if (context.AbiTypeShapeResolver.IsComplexStruct(uOut)) + else if (context.AbiTypeKindResolver.IsComplexStruct(uOut)) { writer.WriteLine($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.Dispose(__{localName});"); } @@ -1403,7 +1403,7 @@ internal static void EmitParamArgConversion(IndentedTextWriter writer, Projectio } // Enums: function pointer signature uses the projected enum type, so pass directly. - else if (context.AbiTypeShapeResolver.IsEnumType(p.Type)) + else if (context.AbiTypeKindResolver.IsEnumType(p.Type)) { writer.Write(pname); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index 04457ad0b..38c9ada0e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -89,7 +89,7 @@ private static string GetAbiFieldType(ProjectionEmitContext context, TypeSignatu return "void*"; } - if (context.AbiTypeShapeResolver.IsMappedAbiValueType(ft)) + if (context.AbiTypeKindResolver.IsMappedAbiValueType(ft)) { return AbiTypeHelpers.GetMappedAbiTypeName(ft); } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index cc7740712..c81275ed4 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -194,7 +194,7 @@ public override unsafe void Invoke( continue; } - if (!context.AbiTypeShapeResolver.IsRuntimeClassOrInterface(p.Type) && !p.Type.IsObject()) + if (!context.AbiTypeKindResolver.IsRuntimeClassOrInterface(p.Type) && !p.Type.IsObject()) { continue; } @@ -219,7 +219,7 @@ public override unsafe void Invoke( { ParameterInfo p = sig.Parameters[i]; - if (!context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) + if (!context.AbiTypeKindResolver.IsMappedAbiValueType(p.Type)) { continue; } @@ -266,7 +266,7 @@ public override unsafe void Invoke( continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -382,7 +382,7 @@ public override unsafe void Invoke( else if (isArr) { TypeSignature elemT = ((SzArrayTypeSignature)p.Type).BaseType; - bool isBlittableElem = context.AbiTypeShapeResolver.IsBlittableAbiElement(elemT); + bool isBlittableElem = context.AbiTypeKindResolver.IsBlittableAbiElement(elemT); bool isStringElem = elemT.IsString(); if (isBlittableElem) @@ -446,7 +446,7 @@ public override unsafe void Invoke( continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } @@ -521,7 +521,7 @@ public override unsafe void Invoke( // For enums, cast to underlying type. For bool, cast to byte. For char, cast to ushort. // For string params, use the marshalled HString from the fixed block. // For runtime class / object / generic instance params, use __.GetThisPtrUnsafe(). - if (context.AbiTypeShapeResolver.IsEnumType(p.Type)) + if (context.AbiTypeKindResolver.IsEnumType(p.Type)) { // No cast needed: function pointer signature uses the projected enum type. writer.Write(pname); @@ -544,11 +544,11 @@ public override unsafe void Invoke( { writer.Write($"__{raw}.ConvertToUnmanagedUnsafe()"); } - else if (context.AbiTypeShapeResolver.IsReferenceTypeOrGenericInstance(p.Type)) + else if (context.AbiTypeKindResolver.IsReferenceTypeOrGenericInstance(p.Type)) { writer.Write($"__{raw}.GetThisPtrUnsafe()"); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(p.Type)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(p.Type)) { writer.Write($"__{raw}"); } @@ -614,7 +614,7 @@ public override unsafe void Invoke( continue; } - if (context.AbiTypeShapeResolver.IsBlittableAbiElement(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsBlittableAbiElement(szArr.BaseType)) { continue; } diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 6ff45ab37..22acee0b0 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -45,7 +45,7 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P // "Almost-blittable" includes blittable + bool/char fields. Excludes string/object fields. // Use the same predicate as IsAnyStruct (which is now scoped to almost-blittable). TypeDefOrRefSignature sig = type.ToTypeSignature(false) is TypeDefOrRefSignature td2 ? td2 : null!; - bool almostBlittable = cat == TypeCategory.Struct && (sig is null || context.AbiTypeShapeResolver.IsBlittableStruct(sig)); + bool almostBlittable = cat == TypeCategory.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); bool isEnum = cat == TypeCategory.Enum; // Complex structs are non-almost-blittable structs with reference fields (string, object, etc.). @@ -115,7 +115,7 @@ public static unsafe class {{nameStripped}}Marshaller { writer.Write($"HStringMarshaller.ConvertToUnmanaged(value.{fname})"); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(ft)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(ft)) { writer.Write($"{AbiTypeHelpers.GetMappedMarshallerName(ft)}.ConvertToUnmanaged(value.{fname})"); } @@ -176,7 +176,7 @@ public static unsafe class {{nameStripped}}Marshaller { writer.Write($"HStringMarshaller.ConvertToManaged(value.{fname})"); } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(ft)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(ft)) { writer.Write($"{AbiTypeHelpers.GetMappedMarshallerName(ft)}.ConvertToManaged(value.{fname})"); } @@ -229,7 +229,7 @@ public static void Dispose({{abi}} value) // (the ABI representation is just an int HRESULT). Skip Dispose entirely. continue; } - else if (context.AbiTypeShapeResolver.IsMappedAbiValueType(ft)) + else if (context.AbiTypeKindResolver.IsMappedAbiValueType(ft)) { // Mapped value types (DateTime/TimeSpan) have no per-value resources to // release — the ABI representation is just an int64 diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs b/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs index ce634c74b..1be2c4aa9 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionEmitContext.cs @@ -51,7 +51,7 @@ internal sealed class ProjectionEmitContext(Settings settings, MetadataCache cac /// /// Gets the resolver used to classify type signatures by their ABI marshalling shape. /// - public AbiTypeShapeResolver AbiTypeShapeResolver { get; } = new AbiTypeShapeResolver(cache); + public AbiTypeKindResolver AbiTypeKindResolver { get; } = new AbiTypeKindResolver(cache); /// /// Gets a value indicating whether platform-attribute computation should suppress platforms diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index af0b02694..33e38a4ea 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -30,7 +30,7 @@ internal static partial class AbiTypeHelpers /// The ABI C# type name as a string (no trailing punctuation). public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSignature sig) { - if (sig.IsAbiRefLike(context.AbiTypeShapeResolver)) + if (sig.IsAbiRefLike(context.AbiTypeKindResolver)) { return "void*"; } @@ -45,7 +45,7 @@ public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSign return WellKnownAbiTypeNames.AbiSystemException; } - if (context.AbiTypeShapeResolver.IsComplexStruct(sig)) + if (context.AbiTypeKindResolver.IsComplexStruct(sig)) { return GetAbiStructTypeName(context, sig); } @@ -55,7 +55,7 @@ public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSign return GetMappedAbiTypeName(sig); } - if (context.AbiTypeShapeResolver.IsBlittableStruct(sig)) + if (context.AbiTypeKindResolver.IsBlittableStruct(sig)) { return GetBlittableStructAbiType(context, sig); } @@ -66,7 +66,7 @@ public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSign /// /// Returns the ABI C# type name for a single SZ-array element appearing as the data /// parameter in array-marshaller UnsafeAccessor signatures (e.g. ConvertToManaged_X, - /// Free_X). Dispatched by : + /// Free_X). Dispatched by : /// reference-pointer → void*, HResult → global::ABI.System.Exception, mapped value /// type → mapped ABI name, complex struct → ABI struct name, blittable struct → blittable ABI /// struct, primitive → primitive ABI type. @@ -76,7 +76,7 @@ public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSign /// The ABI C# type name as a string (no trailing punctuation). public static string GetArrayElementAbiType(ProjectionEmitContext context, TypeSignature elementType) { - return context.AbiTypeShapeResolver.ClassifyArrayElement(elementType) switch + return context.AbiTypeKindResolver.ClassifyArrayElement(elementType) switch { AbiArrayElementKind.RefLikeVoidStar => "void*", AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, @@ -99,7 +99,7 @@ public static string GetArrayElementAbiType(ProjectionEmitContext context, TypeS /// The storage C# type name as a string (no trailing punctuation). public static string GetArrayElementStorageType(ProjectionEmitContext context, TypeSignature elementType) { - return context.AbiTypeShapeResolver.ClassifyArrayElement(elementType) switch + return context.AbiTypeKindResolver.ClassifyArrayElement(elementType) switch { AbiArrayElementKind.MappedValueType => GetMappedAbiTypeName(elementType), AbiArrayElementKind.ComplexStruct => GetAbiStructTypeName(context, elementType), diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 5fa86348c..9bf39d487 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -83,7 +83,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext // fields) can pass through using the projected type since the C# layout // matches the WinRT ABI directly. Truly complex structs (with string/object/ // Nullable fields) need the ABI struct. - if (context.AbiTypeShapeResolver.IsBlittableStruct(dts)) + if (context.AbiTypeKindResolver.IsBlittableStruct(dts)) { TypedefNameWriter.WriteTypedefName(writer, context, d.Type, TypedefNameType.Projected, true); } @@ -161,7 +161,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext break; } - if (context.AbiTypeShapeResolver.IsBlittableStruct(rd.ToTypeSignature())) + if (context.AbiTypeKindResolver.IsBlittableStruct(rd.ToTypeSignature())) { TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); } diff --git a/src/WinRT.Projection.Writer/Models/AbiTypeShapeKind.cs b/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs similarity index 98% rename from src/WinRT.Projection.Writer/Models/AbiTypeShapeKind.cs rename to src/WinRT.Projection.Writer/Models/AbiTypeKind.cs index e4140cc42..052ff047c 100644 --- a/src/WinRT.Projection.Writer/Models/AbiTypeShapeKind.cs +++ b/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs @@ -7,7 +7,7 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// Classification of a WinRT ABI type's marshalling shape, used to drive the writer's /// decisions about how to emit converters and parameter handling. /// -internal enum AbiTypeShapeKind +internal enum AbiTypeKind { /// /// The shape could not be determined (e.g. unresolved reference). diff --git a/src/WinRT.Projection.Writer/Models/AbiTypeShape.cs b/src/WinRT.Projection.Writer/Models/AbiTypeShape.cs deleted file mode 100644 index bc23111db..000000000 --- a/src/WinRT.Projection.Writer/Models/AbiTypeShape.cs +++ /dev/null @@ -1,14 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using AsmResolver.DotNet.Signatures; - -namespace WindowsRuntime.ProjectionWriter.Models; - -/// -/// Immutable record describing the ABI marshalling shape of a single WinRT type signature -/// (the kind of marshalling needed, plus the underlying type signature). -/// -/// The classification of the type signature's ABI shape. -/// The original type signature this shape was derived from. -internal sealed record AbiTypeShape(AbiTypeShapeKind Kind, TypeSignature Signature); \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index 52a2985d5..eaed251e4 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -12,9 +12,9 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// per-parameter-shape probes that drive try/finally emission, so the calling code only /// needs to walk the parameter list once instead of re-deriving each flag inline. /// -/// The resolved of the return type, or when the method returns void. +/// The resolved of the return type, or when the method returns void. /// True when the return type is . -/// True when the return type's shape is reference-typed (per ). +/// True when the return type's shape is reference-typed (per ). /// True when the return type is a blittable struct. /// True when the return type is a complex struct. /// True when the return type is an SZ-array whose element is a known ABI element shape (blittable, ref-like, complex struct, HResult-exception, or mapped value type). @@ -25,7 +25,7 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// True when at least one parameter has Pass/Fill-array category and its element type is neither blittable nor mapped value type. /// True when at least one In/Ref parameter's underlying type is a complex struct (needs marshaller initialisation). internal readonly record struct MethodSignatureMarshallingFacts( - AbiTypeShapeKind ReturnShape, + AbiTypeKind ReturnShape, bool ReturnIsString, bool ReturnIsRefType, bool ReturnIsBlittableStruct, @@ -51,18 +51,18 @@ internal readonly record struct MethodSignatureMarshallingFacts( /// Computes the marshalling facts for using /// for shape classification. /// - public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiTypeShapeResolver resolver) + public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiTypeKindResolver resolver) { TypeSignature? rt = sig.ReturnType; - AbiTypeShapeKind returnShape = rt is null ? AbiTypeShapeKind.Unknown : resolver.Resolve(rt).Kind; + AbiTypeKind returnShape = rt is null ? AbiTypeKind.Unknown : resolver.Resolve(rt); - bool returnIsString = returnShape == AbiTypeShapeKind.String; + bool returnIsString = returnShape == AbiTypeKind.String; bool returnIsRefType = returnShape.IsReferenceType(); - bool returnIsBlittableStruct = returnShape == AbiTypeShapeKind.BlittableStruct; - bool returnIsComplexStruct = returnShape == AbiTypeShapeKind.ComplexStruct; + bool returnIsBlittableStruct = returnShape == AbiTypeKind.BlittableStruct; + bool returnIsComplexStruct = returnShape == AbiTypeKind.ComplexStruct; bool returnIsReceiveArray = rt is SzArrayTypeSignature retSz && resolver.IsRecognizedReceiveArrayElement(retSz.BaseType); - bool returnIsHResultException = returnShape == AbiTypeShapeKind.HResultException; + bool returnIsHResultException = returnShape == AbiTypeKind.HResultException; bool returnIsSystemTypeForCleanup = rt is not null && rt.IsSystemType(); bool hasOutNeedsCleanup = false; diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs similarity index 87% rename from src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs rename to src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index 343deeb4d..92c7145f6 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeShapeResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -10,7 +10,7 @@ namespace WindowsRuntime.ProjectionWriter.Resolvers; /// -/// Classifies WinRT type signatures by their ABI marshalling shape (see ). +/// Classifies WinRT type signatures by their ABI marshalling shape (see ). /// /// /// The resolver is constructed with a reference to the so it can @@ -20,7 +20,7 @@ namespace WindowsRuntime.ProjectionWriter.Resolvers; /// resolver's classification rather than reaching for the per-shape predicates directly. /// /// The metadata cache used for cross-module type resolution. -internal sealed class AbiTypeShapeResolver(MetadataCache cache) +internal sealed class AbiTypeKindResolver(MetadataCache cache) { /// /// Gets the metadata cache used for cross-module type resolution. @@ -28,14 +28,13 @@ internal sealed class AbiTypeShapeResolver(MetadataCache cache) public MetadataCache Cache { get; } = cache; /// - /// Classifies as an . + /// Classifies by its WinRT ABI marshalling shape. /// /// The type signature to classify. - /// The shape classification. - public AbiTypeShape Resolve(TypeSignature signature) + /// The describing the signature's ABI shape; for signatures that don't match any known WinRT marshalling shape. + public AbiTypeKind Resolve(TypeSignature signature) { - AbiTypeShapeKind kind = ClassifyShape(signature); - return new AbiTypeShape(kind, signature); + return ClassifyShape(signature); } /// @@ -46,7 +45,7 @@ public AbiTypeShape Resolve(TypeSignature signature) /// The type signature to classify. /// if blittable primitive or enum; otherwise . public bool IsBlittablePrimitive(TypeSignature signature) - => Resolve(signature).Kind is AbiTypeShapeKind.BlittablePrimitive or AbiTypeShapeKind.Enum; + => Resolve(signature) is AbiTypeKind.BlittablePrimitive or AbiTypeKind.Enum; /// /// Returns whether is a WinRT enum (marshalled as its underlying integer). @@ -54,7 +53,7 @@ public bool IsBlittablePrimitive(TypeSignature signature) /// The type signature to classify. /// if an enum; otherwise . public bool IsEnumType(TypeSignature signature) - => Resolve(signature).Kind == AbiTypeShapeKind.Enum; + => Resolve(signature) == AbiTypeKind.Enum; /// /// Returns whether is a WinRT struct that flows across the ABI by value @@ -64,7 +63,7 @@ public bool IsEnumType(TypeSignature signature) /// The type signature to classify. /// if a blittable struct; otherwise . public bool IsBlittableStruct(TypeSignature signature) - => Resolve(signature).Kind == AbiTypeShapeKind.BlittableStruct; + => Resolve(signature) == AbiTypeKind.BlittableStruct; /// /// Returns whether is any WinRT struct that flows across the ABI by value @@ -73,7 +72,7 @@ public bool IsBlittableStruct(TypeSignature signature) /// The type signature to classify. /// if a struct; otherwise . public bool IsAnyStruct(TypeSignature signature) - => Resolve(signature).Kind is AbiTypeShapeKind.BlittableStruct or AbiTypeShapeKind.ComplexStruct; + => Resolve(signature) is AbiTypeKind.BlittableStruct or AbiTypeKind.ComplexStruct; /// /// Returns whether is a WinRT struct that has at least one reference-type @@ -82,7 +81,7 @@ public bool IsAnyStruct(TypeSignature signature) /// The type signature to classify. /// if a complex struct; otherwise . public bool IsComplexStruct(TypeSignature signature) - => Resolve(signature).Kind == AbiTypeShapeKind.ComplexStruct; + => Resolve(signature) == AbiTypeKind.ComplexStruct; /// /// Returns whether is a WinRT runtime class, interface, or delegate @@ -91,7 +90,7 @@ public bool IsComplexStruct(TypeSignature signature) /// The type signature to classify. /// if a class / interface / delegate; otherwise . public bool IsRuntimeClassOrInterface(TypeSignature signature) - => Resolve(signature).Kind is AbiTypeShapeKind.RuntimeClassOrInterface or AbiTypeShapeKind.Delegate; + => Resolve(signature) is AbiTypeKind.RuntimeClassOrInterface or AbiTypeKind.Delegate; /// /// Returns whether is a reference type that crosses the ABI as @@ -110,7 +109,7 @@ public bool IsReferenceTypeOrGenericInstance(TypeSignature signature) /// The type signature to classify. /// if mapped; otherwise . public bool IsMappedAbiValueType(TypeSignature signature) - => Resolve(signature).Kind == AbiTypeShapeKind.MappedAbiValueType; + => Resolve(signature) == AbiTypeKind.MappedAbiValueType; /// /// Returns whether is a blittable element shape suitable for @@ -216,49 +215,49 @@ public AbiArrayElementKind ClassifyArrayElement(TypeSignature elementType) } /// - /// Inner classification routine. Returns the resolved for - /// ; returns when the + /// Inner classification routine. Returns the resolved for + /// ; returns when the /// signature does not match any known WinRT marshalling shape (typically because of an /// unresolved cross-module reference). /// /// The type signature to classify. /// The classification kind. - private AbiTypeShapeKind ClassifyShape(TypeSignature signature) + private AbiTypeKind ClassifyShape(TypeSignature signature) { // Cheap top-level shape checks that don't need the cache. if (signature.IsString()) { - return AbiTypeShapeKind.String; + return AbiTypeKind.String; } if (signature.IsObject()) { - return AbiTypeShapeKind.Object; + return AbiTypeKind.Object; } if (signature.IsHResultException()) { - return AbiTypeShapeKind.HResultException; + return AbiTypeKind.HResultException; } if (signature.IsSystemType()) { - return AbiTypeShapeKind.SystemType; + return AbiTypeKind.SystemType; } if (signature.IsNullableT()) { - return AbiTypeShapeKind.NullableT; + return AbiTypeKind.NullableT; } if (signature is SzArrayTypeSignature) { - return AbiTypeShapeKind.Array; + return AbiTypeKind.Array; } if (signature.IsGenericInstance()) { - return AbiTypeShapeKind.GenericInstance; + return AbiTypeKind.GenericInstance; } // Cache-aware classifications. These are evaluated in the same order the writer's @@ -266,22 +265,22 @@ private AbiTypeShapeKind ClassifyShape(TypeSignature signature) // resolver returns the same shape the legacy code path would have inferred. if (AbiTypeHelpers.IsMappedAbiValueType(signature)) { - return AbiTypeShapeKind.MappedAbiValueType; + return AbiTypeKind.MappedAbiValueType; } if (AbiTypeHelpers.IsBlittablePrimitive(Cache, signature)) { - return signature is CorLibTypeSignature ? AbiTypeShapeKind.BlittablePrimitive : AbiTypeShapeKind.Enum; + return signature is CorLibTypeSignature ? AbiTypeKind.BlittablePrimitive : AbiTypeKind.Enum; } if (AbiTypeHelpers.IsComplexStruct(Cache, signature)) { - return AbiTypeShapeKind.ComplexStruct; + return AbiTypeKind.ComplexStruct; } if (AbiTypeHelpers.IsAnyStruct(Cache, signature)) { - return AbiTypeShapeKind.BlittableStruct; + return AbiTypeKind.BlittableStruct; } if (AbiTypeHelpers.IsRuntimeClassOrInterface(Cache, signature)) @@ -290,12 +289,12 @@ private AbiTypeShapeKind ClassifyShape(TypeSignature signature) td.Type is TypeDefinition def && TypeCategorization.GetCategory(def) == TypeCategory.Delegate) { - return AbiTypeShapeKind.Delegate; + return AbiTypeKind.Delegate; } - return AbiTypeShapeKind.RuntimeClassOrInterface; + return AbiTypeKind.RuntimeClassOrInterface; } - return AbiTypeShapeKind.Unknown; + return AbiTypeKind.Unknown; } } From f05967641b72be142f4774bd033744969155b765 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 13:07:47 -0700 Subject: [PATCH 145/171] Rename ParameterCategoryResolver.GetParamCategory to Resolve MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Aligns the method name with AbiTypeKindResolver.Resolve, giving both classification resolvers a uniform 'Resolve()' entry point. Pure rename — generated projection output remains byte-identical across all 3 regen scenarios (0 diffs). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceFactory.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 8 +++--- .../AbiMethodBodyFactory.RcwCaller.cs | 28 +++++++++---------- .../Factories/ClassMembersFactory.cs | 2 +- .../ConstructorFactory.FactoryCallbacks.cs | 16 +++++------ .../Factories/MethodFactory.cs | 2 +- .../Models/MethodSignatureInfoExtensions.cs | 8 +++--- .../Resolvers/ParameterCategoryResolver.cs | 2 +- 8 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index e1edae895..43455809b 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -77,7 +77,7 @@ public static void WriteAbiParameterTypesPointer(IndentedTextWriter writer, Proj { writer.Write(", "); ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); string paramName = p.GetRawName(); WriteEscapedIdentifierCallback name = IdentifierEscaping.WriteEscapedIdentifier(paramName); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 8edf90cbb..b2f80ec39 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -223,7 +223,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { @@ -385,7 +385,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection """); } ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (cat == ParameterCategory.Out) { @@ -631,7 +631,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { @@ -662,7 +662,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 058abe20d..62c6363ee 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -53,7 +53,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec _ = fp.Append("void*"); foreach (ParameterInfo p in sig.Parameters) { - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (cat.IsArrayInput()) { @@ -250,7 +250,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { ParameterInfo p = sig.Parameters[i]; - if (ParameterCategoryResolver.GetParamCategory(p) != ParameterCategory.In) + if (ParameterCategoryResolver.Resolve(p) != ParameterCategory.In) { continue; } @@ -270,7 +270,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { ParameterInfo p = sig.Parameters[i]; - if (ParameterCategoryResolver.GetParamCategory(p) != ParameterCategory.In) + if (ParameterCategoryResolver.Resolve(p) != ParameterCategory.In) { continue; } @@ -292,7 +292,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsScalarInput()) { @@ -343,7 +343,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { @@ -458,7 +458,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsScalarInput()) { @@ -483,7 +483,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { ParameterInfo p = sig.Parameters[i]; - if (ParameterCategoryResolver.GetParamCategory(p) != ParameterCategory.In) + if (ParameterCategoryResolver.Resolve(p) != ParameterCategory.In) { continue; } @@ -516,7 +516,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (p.Type.IsString() || p.Type.IsSystemType()) { @@ -539,7 +539,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (cat == ParameterCategory.Ref) { @@ -571,7 +571,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); bool isString = p.Type.IsString(); bool isType = p.Type.IsSystemType(); bool isPassArray = cat.IsArrayInput(); @@ -661,7 +661,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { @@ -767,7 +767,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (cat.IsArrayInput()) { @@ -1144,7 +1144,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsScalarInput()) { @@ -1170,7 +1170,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 8c0c3e0e1..e7df4fda8 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -67,7 +67,7 @@ internal static WriteParameterNameWithModifierCallback WriteParameterNameWithMod /// internal static void WriteParameterNameWithModifier(IndentedTextWriter writer, ProjectionEmitContext context, ParameterInfo p) { - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); switch (cat) { case ParameterCategory.Out: diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index c81275ed4..5e3d20d81 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -130,7 +130,7 @@ public override unsafe void Invoke( ParameterInfo p = sig.Parameters[i]; string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); // For array params, the bind type is ReadOnlySpan / Span (not the SzArray). if (cat == ParameterCategory.PassArray) @@ -254,7 +254,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { @@ -338,7 +338,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (p.Type.IsString() || p.Type.IsSystemType()) { @@ -357,7 +357,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); bool isStr = p.Type.IsString(); bool isType = p.Type.IsSystemType(); bool isArr = cat.IsArrayInput(); @@ -434,7 +434,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { @@ -483,7 +483,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (cat.IsArrayInput()) { @@ -505,7 +505,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); string raw = p.GetRawName(); string pname = IdentifierEscaping.EscapeIdentifier(raw); writer.Write(isMultiline: true, """ @@ -602,7 +602,7 @@ public override unsafe void Invoke( for (int i = 0; i < paramCount; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (!cat.IsArrayInput()) { diff --git a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs index 0beb9ac00..99b2c21ff 100644 --- a/src/WinRT.Projection.Writer/Factories/MethodFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MethodFactory.cs @@ -67,7 +67,7 @@ public static WriteProjectedSignatureCallback WriteProjectedSignature(Projection /// The parameter info. public static void WriteProjectionParameterType(IndentedTextWriter writer, ProjectionEmitContext context, ParameterInfo p) { - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); switch (cat) { case ParameterCategory.Out: diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs index 02e4a65c2..7dda551a6 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs @@ -26,7 +26,7 @@ internal static class MethodSignatureInfoExtensions for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - yield return (i, p, ParameterCategoryResolver.GetParamCategory(p)); + yield return (i, p, ParameterCategoryResolver.Resolve(p)); } } @@ -40,7 +40,7 @@ internal static class MethodSignatureInfoExtensions { ParameterInfo p = sig.Parameters[i]; - if (ParameterCategoryResolver.GetParamCategory(p) == category) + if (ParameterCategoryResolver.Resolve(p) == category) { yield return (i, p); } @@ -57,7 +57,7 @@ internal static class MethodSignatureInfoExtensions for (int i = 0; i < sig.Parameters.Count; i++) { ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.GetParamCategory(p); + ParameterCategory cat = ParameterCategoryResolver.Resolve(p); if (cat.IsAnyArray()) { @@ -73,7 +73,7 @@ public bool HasParameterOfCategory(ParameterCategory category) { for (int i = 0; i < sig.Parameters.Count; i++) { - if (ParameterCategoryResolver.GetParamCategory(sig.Parameters[i]) == category) + if (ParameterCategoryResolver.Resolve(sig.Parameters[i]) == category) { return true; } diff --git a/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs b/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs index 3fc87dd29..9b546e54b 100644 --- a/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/ParameterCategoryResolver.cs @@ -17,7 +17,7 @@ internal static class ParameterCategoryResolver /// /// The parameter to classify. /// The classified parameter category. - public static ParameterCategory GetParamCategory(ParameterInfo p) + public static ParameterCategory Resolve(ParameterInfo p) { bool isArray = p.Type is SzArrayTypeSignature; bool isOut = p.Parameter.Definition?.IsOut == true; From 7d440ebc1cec78552362a4fce8b9660f853fdb6d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 13:14:56 -0700 Subject: [PATCH 146/171] Inline ClassifyShape into Resolve Move the type-shape classification logic directly into Resolve and remove the private ClassifyShape method. Resolve now performs cheap top-level checks (string, object, HRESULT exception, System.Type, Nullable, arrays, generic instances) before running cache-aware predicates via AbiTypeHelpers in the same order as the legacy path. Special-case delegate detection for runtime types and return AbiTypeKind.Unknown as a fallback. This removes an extra indirection and consolidates the classification logic in one place. --- .../Helpers/AbiTypeHelpers.Blittability.cs | 12 +- .../Resolvers/AbiTypeKindResolver.cs | 159 ++++++++---------- 2 files changed, 78 insertions(+), 93 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 1ef2ec6df..2583d2b54 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -181,17 +181,13 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur return cat is TypeCategory.Class or TypeCategory.Interface or TypeCategory.Delegate; } - // Cross-module typeref: try to resolve via the metadata cache to check category. - string ns = td.Type?.Namespace?.Value ?? string.Empty; - string name = td.Type?.Name?.Value ?? string.Empty; + // Cross-module typeref: try to resolve via the metadata cache to check category + (string ns, string name) = td.Type.Names(); + // If the type is in 'System', we already know the set of possible types if (ns == "System") { - return name switch - { - "Uri" or "Type" or "IDisposable" or "Exception" => true, - _ => false, - }; + return name is "Uri" or "Type" or "IDisposable" or "Exception"; } if (cache is not null) diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index 92c7145f6..fdd6d6800 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -34,7 +34,80 @@ internal sealed class AbiTypeKindResolver(MetadataCache cache) /// The describing the signature's ABI shape; for signatures that don't match any known WinRT marshalling shape. public AbiTypeKind Resolve(TypeSignature signature) { - return ClassifyShape(signature); + // Cheap top-level shape checks that don't need the cache + if (signature.IsString()) + { + return AbiTypeKind.String; + } + + if (signature.IsObject()) + { + return AbiTypeKind.Object; + } + + if (signature.IsHResultException()) + { + return AbiTypeKind.HResultException; + } + + if (signature.IsSystemType()) + { + return AbiTypeKind.SystemType; + } + + if (signature.IsNullableT()) + { + return AbiTypeKind.NullableT; + } + + if (signature is SzArrayTypeSignature) + { + return AbiTypeKind.Array; + } + + if (signature.IsGenericInstance()) + { + return AbiTypeKind.GenericInstance; + } + + // Cache-aware classifications. These are evaluated in the same order the writer's + // emission paths historically queried the inline AbiTypeHelpers predicates so the + // resolver returns the same shape the legacy code path would have inferred. + if (AbiTypeHelpers.IsMappedAbiValueType(signature)) + { + return AbiTypeKind.MappedAbiValueType; + } + + if (AbiTypeHelpers.IsBlittablePrimitive(Cache, signature)) + { + return signature is CorLibTypeSignature + ? AbiTypeKind.BlittablePrimitive + : AbiTypeKind.Enum; + } + + if (AbiTypeHelpers.IsComplexStruct(Cache, signature)) + { + return AbiTypeKind.ComplexStruct; + } + + if (AbiTypeHelpers.IsAnyStruct(Cache, signature)) + { + return AbiTypeKind.BlittableStruct; + } + + if (AbiTypeHelpers.IsRuntimeClassOrInterface(Cache, signature)) + { + if (signature is TypeDefOrRefSignature td && + td.Type is TypeDefinition def && + TypeCategorization.GetCategory(def) == TypeCategory.Delegate) + { + return AbiTypeKind.Delegate; + } + + return AbiTypeKind.RuntimeClassOrInterface; + } + + return AbiTypeKind.Unknown; } /// @@ -213,88 +286,4 @@ public AbiArrayElementKind ClassifyArrayElement(TypeSignature elementType) return AbiArrayElementKind.BlittablePrimitive; } - - /// - /// Inner classification routine. Returns the resolved for - /// ; returns when the - /// signature does not match any known WinRT marshalling shape (typically because of an - /// unresolved cross-module reference). - /// - /// The type signature to classify. - /// The classification kind. - private AbiTypeKind ClassifyShape(TypeSignature signature) - { - // Cheap top-level shape checks that don't need the cache. - if (signature.IsString()) - { - return AbiTypeKind.String; - } - - if (signature.IsObject()) - { - return AbiTypeKind.Object; - } - - if (signature.IsHResultException()) - { - return AbiTypeKind.HResultException; - } - - if (signature.IsSystemType()) - { - return AbiTypeKind.SystemType; - } - - if (signature.IsNullableT()) - { - return AbiTypeKind.NullableT; - } - - if (signature is SzArrayTypeSignature) - { - return AbiTypeKind.Array; - } - - if (signature.IsGenericInstance()) - { - return AbiTypeKind.GenericInstance; - } - - // Cache-aware classifications. These are evaluated in the same order the writer's - // emission paths historically queried the inline AbiTypeHelpers predicates so the - // resolver returns the same shape the legacy code path would have inferred. - if (AbiTypeHelpers.IsMappedAbiValueType(signature)) - { - return AbiTypeKind.MappedAbiValueType; - } - - if (AbiTypeHelpers.IsBlittablePrimitive(Cache, signature)) - { - return signature is CorLibTypeSignature ? AbiTypeKind.BlittablePrimitive : AbiTypeKind.Enum; - } - - if (AbiTypeHelpers.IsComplexStruct(Cache, signature)) - { - return AbiTypeKind.ComplexStruct; - } - - if (AbiTypeHelpers.IsAnyStruct(Cache, signature)) - { - return AbiTypeKind.BlittableStruct; - } - - if (AbiTypeHelpers.IsRuntimeClassOrInterface(Cache, signature)) - { - if (signature is TypeDefOrRefSignature td && - td.Type is TypeDefinition def && - TypeCategorization.GetCategory(def) == TypeCategory.Delegate) - { - return AbiTypeKind.Delegate; - } - - return AbiTypeKind.RuntimeClassOrInterface; - } - - return AbiTypeKind.Unknown; - } } From e0bfb8c935631a2a1b7496483437ebc32d18a700 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 13:19:22 -0700 Subject: [PATCH 147/171] Remove dead 'System' shortcut in AbiTypeHelpers.IsRuntimeClassOrInterface The helper had a special-case fast path for cross-module typerefs with the 'System' namespace, returning true for 'Uri', 'Type', 'IDisposable', 'Exception'. This was both wrong and incomplete: - 'Type' and 'Exception' are NOT runtime class/interface/delegate at the WinRT ABI -- they're mapped to value-type structs (Windows.UI.Xaml.Interop.TypeName and Windows.Foundation.HResult respectively), so claiming RCI for them is semantically incorrect. - 'IServiceProvider' (mapped to Microsoft.UI.Xaml.IXamlServiceProvider, an interface) was missing from the list entirely. The reason neither bug fired in practice: the System block was dead code on the WinMD-reading path. Custom-mapped types appear in WinMD metadata under their WinRT names (Windows.Foundation.Uri, Windows.Foundation.HResult, Windows.UI.Xaml.Interop.TypeName, etc.), not their .NET-mapped System.* names -- so a cross-module typeref with ns == 'System' is never produced. And for any synthetic signature that DOES reach Resolve with a System.* form, the top-level filters in Resolve (IsHResultException / IsSystemType) intercept them before this helper is consulted. Confirmed empirically: removing the whole block produces 0 diffs across all 3 regen scenarios. Falling through to the cache resolution path (then the !td.IsValueType fallback) handles every actual call site correctly, with no special-case bookkeeping. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Helpers/AbiTypeHelpers.Blittability.cs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 2583d2b54..a9e6aa38e 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -184,12 +184,6 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur // Cross-module typeref: try to resolve via the metadata cache to check category (string ns, string name) = td.Type.Names(); - // If the type is in 'System', we already know the set of possible types - if (ns == "System") - { - return name is "Uri" or "Type" or "IDisposable" or "Exception"; - } - if (cache is not null) { TypeDefinition? resolved = cache.Find(ns, name); From cc421c02b4bff53eec19758cb8087bbaf79265e1 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 13:25:26 -0700 Subject: [PATCH 148/171] Remove dead .NET-side checks for types absent from .winmd input Per follow-up to f1a1ed93: WinMD metadata always carries types under their WinRT names. The custom mapping to System.* names happens only on the OUTPUT side (in the projection source the writer emits). Several classifier predicates on the INPUT side were probing for the .NET-side name as an alternative -- branches that never fire. Empirically verified by removing each candidate and running Validate-All across all 3 regen scenarios: - IsHResultException 'System.Exception' branch -- DEAD (WinMD only ever carries Windows.Foundation.HResult). - IsNullableT 'System.Nullable' branch -- DEAD (WinMD only ever carries Windows.Foundation.IReference). - AbiTypeHelpers.Marshallers 'System.Nullable' branch -- DEAD (same reason; the inline comment in the helper already said so). Counter-example NOT removed: IsSystemType (and TypeSemantics.SystemType) still check 'System.Type' -- those branches ARE live because the ECMA-335 custom-attribute blob encoding emits attribute parameters typed as 'Type' as TypeRefs to System.Type directly (not the WinRT TypeName struct). The Windows Foundation metadata winmd (ActivatableAttribute, ComposableAttribute, StyleTypedPropertyAttribute, etc.) exercises this. XML doc updated to record the reason. 0 diffs across all 3 regen scenarios after the cleanup. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeSignatureExtensions.cs | 12 ++++++++++-- .../Helpers/AbiTypeHelpers.Marshallers.cs | 5 ++--- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index f9098fac0..0b49add7c 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -47,6 +47,14 @@ public bool IsObject() /// that resolves to it, including the WinRT Windows.UI.Xaml.Interop.TypeName struct /// that is mapped to it). /// + /// + /// The System.Type branch is live (not dead, despite appearances): per the ECMA-335 + /// custom-attribute blob encoding rules, attribute constructor / field parameters typed as + /// Type are emitted as TypeRefs to System.Type directly, not to the WinRT + /// Windows.UI.Xaml.Interop.TypeName struct. The Windows Foundation metadata winmd + /// (ActivatableAttribute, ComposableAttribute, StyleTypedPropertyAttribute, + /// etc.) is the primary source of these signatures. + /// /// if the signature is the projected ; otherwise . public bool IsSystemType() { @@ -65,7 +73,7 @@ public bool IsHResultException() { (string ns, string name) = sig.Names(); - return (ns == "System" && name == "Exception") || (ns == WindowsFoundation && name == HResult); + return ns == WindowsFoundation && name == HResult; } /// @@ -82,7 +90,7 @@ public bool IsNullableT() (string ns, string name) = gi.GenericType.Names(); - return (ns == WindowsFoundation && name == IReferenceGeneric) || (ns == "System" && name == NullableGeneric); + return ns == WindowsFoundation && name == IReferenceGeneric; } /// diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs index ad216fc3b..facefb4e5 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs @@ -31,9 +31,8 @@ internal static bool TryGetNullablePrimitiveMarshallerName(TypeSignature sig, ou string name = gt?.Name?.Value ?? string.Empty; // In WinMD metadata, Nullable is encoded as Windows.Foundation.IReference. - // It only later gets projected to System.Nullable by the projection layer. - bool isNullable = (ns == "System" && name == NullableGeneric) - || (ns == WindowsFoundation && name == IReferenceGeneric); + // (It only later gets projected to System.Nullable by the projection layer.) + bool isNullable = ns == WindowsFoundation && name == IReferenceGeneric; if (!isNullable) { From 5ee464e2f82fe7430b9b84f1cb30bc24372eba3b Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:21:57 -0700 Subject: [PATCH 149/171] Audit System.* special cases in classifiers: delete dead, comment live There were several uncommented 'ns == \"System\" && name == \"X\"' fast paths sprinkled across the classifiers / TypeSemantics factory. Audited each one empirically by removing it and observing whether output diffs appeared, then either deleted the dead ones or added a brief comment explaining why the live ones are needed. Deleted (dead, fallthrough produces the same answer): - AbiTypeHelpers.IsComplexStruct 'System.Guid' branch -- returns false, and the cache.Find(...) + 'def is null' fallthrough also returns false. Pure redundancy. Kept with a brief comment explaining why: - AbiTypeHelpers.IsAnyStruct 'System.Guid' -- WinRT GUIDs are this BCL struct, but Guid lives in mscorlib (not WinMD), so cache resolution fails and the fallthrough would (incorrectly) classify Guid as Unknown instead of BlittableStruct. - TypeSemantics 'System.Guid' / 'System.Object' -- same mscorlib-only story. Dedicated semantics drive the writers to emit the BCL short name instead of the fully-qualified TypeReference name. - TypeSemantics 'System.Type' -- ECMA-335 attribute-blob encoding emits Type-valued attribute args as TypeRefs to System.Type directly (not the WinRT TypeName struct). ActivatableAttribute, ComposableAttribute, StyleTypedPropertyAttribute, etc. all exercise this path. - AbiTypeHelpers.GetClassHierarchyIndex 'System.Object' -- AsmResolver CAN TryResolve System.Object via the corlib runtime context, which would (incorrectly) make a direct-Object-derivation count as depth 1 instead of 0. Short-circuit avoids the false recursion. Left untouched (already self-documenting via the method's name + XML doc, or via adjacent code context): - TypeDefinitionExtensions.HasNonObjectBaseType -- the System.Object check IS the method's purpose; the name and doc already explain it. - TypedefNameWriter EventSource 'ns == \"System\"' -- post-ApplyMapping; the surrounding code makes the context clear. 0 diffs across all 3 regen scenarios after the audit. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Helpers/AbiTypeHelpers.Blittability.cs | 7 ++----- src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs | 3 +++ src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs | 6 ++++++ 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index a9e6aa38e..5e1319b21 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -273,11 +273,6 @@ internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) { (string ns, string name) = tr.Names(); - if (ns == "System" && name == "Guid") - { - return false; - } - def = cache.Find(ns, name); } @@ -346,6 +341,8 @@ internal static bool IsAnyStruct(MetadataCache cache, TypeSignature sig) { (string ns, string name) = trEarly.Names(); + // 'System.Guid' lives in mscorlib (not in any .winmd): the cache never resolves it, + // so short-circuit to true here. Windows Runtime's 'Guid' is exactly this BCL struct. if (ns == "System" && name == "Guid") { return true; diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 0e493d24f..d1b29a368 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -196,6 +196,9 @@ public static int GetClassHierarchyIndex(MetadataCache cache, TypeDefinition cla (string ns, string nm) = classType.BaseType.Names(); + // 'System.Object' is not in any .winmd, so resolving via the cache fails. But AsmResolver + // can still 'TryResolve' it from the corlib runtime context, which would (incorrectly) + // make a direct-Object-derivation count as depth 1 instead of 0. Short-circuit here. if (ns == "System" && nm == "Object") { return 0; diff --git a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs index 971a2c02e..f6de8fb04 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs @@ -177,16 +177,22 @@ public static TypeSemantics GetFromTypeDefOrRef(ITypeDefOrRef type, bool isValue { (string ns, string name) = reference.Names(); + // 'System.Guid' lives in mscorlib (not in any .winmd), so cache resolution would always + // fail. Surface it as a dedicated semantic so the writers emit the BCL short name. if (ns == "System" && name == "Guid") { return new TypeSemantics.GuidType(); } + // Same handling for 'System.Object' as for 'System.Guid' above if (ns == "System" && name == "Object") { return new TypeSemantics.ObjectType(); } + // 'System.Type' appears verbatim in .winmd-s via the ECMA-335 attribute-blob encoding for + // 'Type'-valued attribute args ('[Activatable]', '[Composable]', etc.), not as the Windows + // Runtime 'TypeName' struct. Surface it as a dedicated semantic. if (ns == "System" && name == "Type") { return new TypeSemantics.SystemType(); From df528ac232d3aa52e700fcfc63b1e16addf2b66a Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:38:12 -0700 Subject: [PATCH 150/171] Replace .Name?.Value/.Namespace?.Value boilerplate with Names()/GetRawName() - Add GetRawName() extension to PropertyDefinition, EventDefinition, FieldDefinition (parallel to the existing MethodDefinition.GetRawName() convention). - Add GetRawName() extension to ITypeDescriptor (efficient single-name access without allocating the namespace string from Names()). - Migrate 55 inline 'X.Name?.Value ?? string.Empty' / 'X.Namespace?.Value ?? string.Empty' sites across 22 files to use the appropriate helper: * ITypeDescriptor name-only sites use GetRawName(). * ITypeDescriptor namespace-only sites use Names().Namespace. * Sites reading both name and namespace deconstruct (ns, name) = X.Names(). * Member sites (Property/Event/Field) use the new GetRawName() extensions. Pure refactor; generated projection output is byte-identical across all regen scenarios. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 12 ++++----- .../Extensions/EventDefinitionExtensions.cs | 25 +++++++++++++++++++ .../Extensions/FieldDefinitionExtensions.cs | 25 +++++++++++++++++++ .../Extensions/ITypeDefOrRefExtensions.cs | 2 +- .../Extensions/ITypeDescriptorExtensions.cs | 10 ++++++++ .../PropertyDefinitionExtensions.cs | 10 ++++++++ .../Factories/AbiClassFactory.cs | 6 ++--- .../Factories/AbiDelegateFactory.cs | 4 +-- .../Factories/AbiInterfaceFactory.cs | 4 +-- .../Factories/AbiInterfaceIDicFactory.cs | 8 +++--- .../AbiMethodBodyFactory.MethodsClass.cs | 6 ++--- .../Factories/ClassFactory.cs | 12 ++++----- ...assMembersFactory.WriteInterfaceMembers.cs | 4 +-- .../Factories/ComponentFactory.cs | 7 +++--- .../ConstructorFactory.AttributedTypes.cs | 2 +- .../ConstructorFactory.Composable.cs | 2 +- .../Factories/CustomAttributeFactory.cs | 2 +- .../Factories/InterfaceFactory.cs | 6 ++--- .../Factories/StructEnumMarshallerFactory.cs | 2 +- .../ProjectionGenerator.Namespace.cs | 2 +- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 3 +-- .../Helpers/AbiTypeHelpers.Blittability.cs | 9 +++---- .../Helpers/AbiTypeHelpers.Marshallers.cs | 6 ++--- .../Helpers/AbiTypeHelpers.cs | 6 +++-- .../Helpers/AttributedTypes.cs | 2 +- .../Metadata/MetadataCache.cs | 2 +- 26 files changed, 122 insertions(+), 57 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs create mode 100644 src/WinRT.Projection.Writer/Extensions/FieldDefinitionExtensions.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 493ccf0c3..68692b054 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -93,7 +93,7 @@ private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext c bool isFlags = TypeCategorization.IsFlagsEnum(type); string enumUnderlyingType = isFlags ? "uint" : "int"; - string typeName = type.Name?.Value ?? string.Empty; + string typeName = type.GetRawName(); WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); WriteValueTypeWinRTClassNameAttributeCallback valueTypeAttr = MetadataAttributeFactory.WriteValueTypeWinRTClassNameAttribute(context, type); @@ -121,7 +121,7 @@ public enum {{typeName}} : {{enumUnderlyingType}} continue; } - string fieldName = field.Name?.Value ?? string.Empty; + string fieldName = field.GetRawName(); string constantValue = field.Constant.FormatLiteral(); // Emits per-enum-field '[SupportedOSPlatform]' when the field has a '[ContractVersion]' @@ -156,7 +156,7 @@ private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext TypeSemantics semantics = TypeSemanticsFactory.Get(field.Signature.FieldType); string fieldType = TypedefNameWriter.WriteProjectionType(context, semantics).Format(); - string fieldName = field.Name?.Value ?? string.Empty; + string fieldName = field.GetRawName(); string paramName = IdentifierEscaping.ToCamelCase(fieldName); bool isInterface = false; @@ -172,7 +172,7 @@ private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext fields.Add((fieldType, fieldName, paramName, isInterface)); } - string projectionName = type.Name?.Value ?? string.Empty; + string projectionName = type.GetRawName(); // Header attributes + struct declaration as a single multiline template. WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); @@ -298,7 +298,7 @@ private static void WriteContract(IndentedTextWriter writer, ProjectionEmitConte return; } - string typeName = type.Name?.Value ?? string.Empty; + string typeName = type.GetRawName(); CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); @@ -348,7 +348,7 @@ private static void WriteDelegate(IndentedTextWriter writer, ProjectionEmitConte /// private static void WriteAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string typeName = type.Name?.Value ?? string.Empty; + string typeName = type.GetRawName(); WriteWinRTMetadataAttributeCallback metadataAttr = MetadataAttributeFactory.WriteWinRTMetadataAttribute(type, context.Cache); WriteTypeCustomAttributesCallback customAttrs = CustomAttributeFactory.WriteTypeCustomAttributes(context, type, true); diff --git a/src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs new file mode 100644 index 000000000..713dadb7c --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/EventDefinitionExtensions.cs @@ -0,0 +1,25 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class EventDefinitionExtensions +{ + extension(EventDefinition evt) + { + /// + /// Returns the event's raw metadata name, falling back to when + /// the metadata name is . Convenience for the + /// evt.Name?.Value ?? string.Empty pattern that appears at many sites. + /// + public string GetRawName() + { + return evt.Name?.Value ?? string.Empty; + } + } +} diff --git a/src/WinRT.Projection.Writer/Extensions/FieldDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/FieldDefinitionExtensions.cs new file mode 100644 index 000000000..d057d1a79 --- /dev/null +++ b/src/WinRT.Projection.Writer/Extensions/FieldDefinitionExtensions.cs @@ -0,0 +1,25 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; + +namespace WindowsRuntime.ProjectionWriter; + +/// +/// Extension methods for . +/// +internal static class FieldDefinitionExtensions +{ + extension(FieldDefinition field) + { + /// + /// Returns the field's raw metadata name, falling back to when + /// the metadata name is . Convenience for the + /// field.Name?.Value ?? string.Empty pattern that appears at many sites. + /// + public string GetRawName() + { + return field.Name?.Value ?? string.Empty; + } + } +} diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs index 4b6dbd45c..7b5fd0d06 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDefOrRefExtensions.cs @@ -24,7 +24,7 @@ internal static class ITypeDefOrRefExtensions /// The type's stripped name. public string GetStrippedName() { - return IdentifierEscaping.StripBackticks(type.Name?.Value ?? string.Empty); + return IdentifierEscaping.StripBackticks(type.GetRawName()); } /// diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs index 7295589a9..e2697a982 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs @@ -22,5 +22,15 @@ internal static class ITypeDescriptorExtensions { return (type.Namespace ?? string.Empty, type.Name ?? string.Empty); } + + /// + /// Returns the type's raw metadata name, falling back to when + /// the metadata name is . More efficient than the Names tuple + /// when only the name is needed (avoids allocating the namespace string). + /// + public string GetRawName() + { + return type.Name ?? string.Empty; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs index 2948e9d3e..e7fe6aa8f 100644 --- a/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/PropertyDefinitionExtensions.cs @@ -24,5 +24,15 @@ internal static class PropertyDefinitionExtensions /// A tuple of (Getter, Setter) accessor methods, either of which may be . public (MethodDefinition? Getter, MethodDefinition? Setter) GetMethods() => (property.GetMethod, property.SetMethod); + + /// + /// Returns the property's raw metadata name, falling back to when + /// the metadata name is . Convenience for the + /// property.Name?.Value ?? string.Empty pattern that appears at many sites. + /// + public string GetRawName() + { + return property.Name?.Value ?? string.Empty; + } } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 1498f0308..37b7dcbe3 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -49,7 +49,7 @@ public static void WriteAbiClass(IndentedTextWriter writer, ProjectionEmitContex internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Namespace?.Value ?? string.Empty; + string typeNs = type.Names().Namespace; string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); @@ -115,7 +115,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedT internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Namespace?.Value ?? string.Empty; + string typeNs = type.Names().Namespace; string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; TypeCategory category = TypeCategorization.GetCategory(type); @@ -199,7 +199,7 @@ public static bool EmitImplType(IndentedTextWriter writer, ProjectionEmitContext internal static void WriteClassMarshallerStub(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Namespace?.Value ?? string.Empty; + string typeNs = type.Names().Namespace; string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); // Get the IID expression for the default interface (used by CreateObject). diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 771dd6831..5b4b066c9 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -312,7 +312,7 @@ public EventState(void* thisPtr, int index) private static void WriteDelegateMarshallerOnly(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Namespace?.Value ?? string.Empty; + string typeNs = type.Names().Namespace; string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); @@ -345,7 +345,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjec private static void WriteDelegateComWrappersCallback(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Namespace?.Value ?? string.Empty; + string typeNs = type.Names().Namespace; string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 43455809b..c2b9b3b81 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -314,7 +314,7 @@ public static nint Vtable if (exclusiveToOwner is not null && !exclusiveIsFactoryOrStatic) { - string ownerNs = exclusiveToOwner.Namespace?.Value ?? string.Empty; + string ownerNs = exclusiveToOwner.Names().Namespace; string ownerNm = exclusiveToOwner.GetStrippedName(); ifaceFullName = string.IsNullOrEmpty(ownerNs) ? GlobalPrefix + ownerNm @@ -324,7 +324,7 @@ public static nint Vtable { // Factory/static interfaces in authoring mode are implemented by the generated // 'global::ABI.Impl..' type that the activation factory CCW exposes. - string ifaceNs = type.Namespace?.Value ?? string.Empty; + string ifaceNs = type.Names().Namespace; string ifaceNm = type.GetStrippedName(); ifaceFullName = string.IsNullOrEmpty(ifaceNs) ? "global::ABI.Impl." + ifaceNm diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index 12680bca5..b7eec64e6 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -260,7 +260,7 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented foreach (PropertyDefinition prop in type.Properties) { (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); - string pname = prop.Name?.Value ?? string.Empty; + string pname = prop.GetRawName(); string propType = InterfaceFactory.WritePropType(context, prop); writer.WriteLine(); @@ -291,7 +291,7 @@ internal static void WriteInterfaceIdicImplMembersForInheritedInterface(Indented foreach (EventDefinition evt in type.Events) { - string evtName = evt.Name?.Value ?? string.Empty; + string evtName = evt.GetRawName(); writer.WriteLine(); WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(isMultiline: true, $$""" @@ -395,7 +395,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite foreach (PropertyDefinition prop in type.Properties) { (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); - string pname = prop.Name?.Value ?? string.Empty; + string pname = prop.GetRawName(); string propType = InterfaceFactory.WritePropType(context, prop); writer.WriteLine(); @@ -444,7 +444,7 @@ internal static void WriteInterfaceIdicImplMembersForInterface(IndentedTextWrite // dispatch through the static ABI Methods class's event accessor (returns an EventSource). foreach (EventDefinition evt in type.Events) { - string evtName = evt.Name?.Value ?? string.Empty; + string evtName = evt.GetRawName(); writer.WriteLine(); WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs index b2e0a1cd5..0fc761730 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.MethodsClass.cs @@ -70,7 +70,7 @@ public static unsafe // Emit property accessors. Each getter / setter consumes one vtable slot — looked up from the underlying method. foreach (PropertyDefinition prop in type.Properties) { - string pname = prop.Name?.Value ?? string.Empty; + string pname = prop.GetRawName(); string propType = InterfaceFactory.WritePropType(context, prop); if (prop.GetMethod is { } getter) @@ -104,7 +104,7 @@ public static unsafe continue; } - string evtName = evt.Name?.Value ?? string.Empty; + string evtName = evt.GetRawName(); TypeSignature evtSig = evt.EventType!.ToTypeSignature(false); bool isGenericEvent = evtSig is GenericInstanceTypeSignature; @@ -135,7 +135,7 @@ public static unsafe if (evtSig is TypeDefOrRefSignature td) { - delegateName = td.Type?.Name?.Value ?? string.Empty; + delegateName = td.Type.GetRawName(); delegateName = IdentifierEscaping.StripBackticks(delegateName); } diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index bd9062817..a8519bb43 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -200,15 +200,15 @@ public static (TypeDefinition? DefaultInterface, System.Collections.Generic.List return aV.Value.CompareTo(bV.Value); } - string aNs = a.Namespace?.Value ?? string.Empty; - string bNs = b.Namespace?.Value ?? string.Empty; + (string aNs, string aName) = a.Names(); + (string bNs, string bName) = b.Names(); if (aNs != bNs) { return StringComparer.Ordinal.Compare(aNs, bNs); } - return StringComparer.Ordinal.Compare(a.Name?.Value ?? string.Empty, b.Name?.Value ?? string.Empty); + return StringComparer.Ordinal.Compare(aName, bName); }); return (defaultIface, exclusiveIfaces); } @@ -348,7 +348,7 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection // Events: dispatch via static ABI class which returns an event source. foreach (EventDefinition evt in staticIface.Events) { - string evtName = evt.Name?.Value ?? string.Empty; + string evtName = evt.GetRawName(); writer.WriteLine(); writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); @@ -374,7 +374,7 @@ public static event {{eventType}} {{evtName}} // Properties (merge getter/setter across interfaces, tracking origin per accessor) foreach (PropertyDefinition prop in staticIface.Properties) { - string propName = prop.Name?.Value ?? string.Empty; + string propName = prop.GetRawName(); (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); string propType = InterfaceFactory.WritePropType(context, prop); @@ -544,7 +544,7 @@ public static void WriteClass(IndentedTextWriter writer, ProjectionEmitContext c private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string typeName = type.Name?.Value ?? string.Empty; + string typeName = type.GetRawName(); int gcPressure = GetGcPressureAmount(type); // Header attributes + class declaration as a single multiline template. diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 8dffae7df..9dfe275c5 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -364,7 +364,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // class on the right _objRef_ field. foreach (PropertyDefinition prop in ifaceType.Properties) { - string name = prop.Name?.Value ?? string.Empty; + string name = prop.GetRawName(); (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); if (!propertyState.TryGetValue(name, out PropertyAccessorState? state)) @@ -410,7 +410,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // handler type. foreach (EventDefinition evt in ifaceType.Events) { - string name = evt.Name?.Value ?? string.Empty; + string name = evt.GetRawName(); if (!writtenEvents.Add(name)) { diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 1df47cea2..2d7d40315 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -49,8 +49,7 @@ public static void AddMetadataTypeEntry(ProjectionEmitContext context, TypeDefin /// public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - string typeName = type.Name?.Value ?? string.Empty; - string typeNs = type.Namespace?.Value ?? string.Empty; + (string typeNs, string typeName) = type.Names(); string projectedTypeName = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, typeName); string factoryTypeName = $"{IdentifierEscaping.StripBackticks(typeName)}ServerActivationFactory"; bool isActivatable = !TypeCategorization.IsStatic(type) && type.HasDefaultConstructor(); @@ -197,7 +196,7 @@ private static void WriteStaticFactoryMethod(IndentedTextWriter writer, Projecti /// private static void WriteStaticFactoryProperty(IndentedTextWriter writer, ProjectionEmitContext context, PropertyDefinition prop, string projectedTypeName) { - string propName = prop.Name?.Value ?? string.Empty; + string propName = prop.GetRawName(); (MethodDefinition? getter, MethodDefinition? setter) = prop.GetMethods(); string propType = GetFactoryPropertyType(context, prop); @@ -227,7 +226,7 @@ private static void WriteStaticFactoryProperty(IndentedTextWriter writer, Projec /// private static void WriteStaticFactoryEvent(IndentedTextWriter writer, ProjectionEmitContext context, EventDefinition evt, string projectedTypeName) { - string evtName = evt.Name?.Value ?? string.Empty; + string evtName = evt.GetRawName(); string evtType = evt.EventType is null ? string.Empty : TypedefNameWriter.WriteTypeName(context, TypeSemanticsFactory.GetFromTypeDefOrRef(evt.EventType), TypedefNameType.Projected, false).Format(); diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 4cf0bc833..4957a3421 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -90,7 +90,7 @@ public static void WriteAttributedTypes(IndentedTextWriter writer, ProjectionEmi /// public static void WriteFactoryConstructors(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition? factoryType, TypeDefinition classType) { - string typeName = classType.Name?.Value ?? string.Empty; + string typeName = classType.GetRawName(); int gcPressure = ClassFactory.GetGcPressureAmount(classType); if (factoryType is not null) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs index 7cda2c6fa..112f3ae30 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.Composable.cs @@ -26,7 +26,7 @@ public static void WriteComposableConstructors(IndentedTextWriter writer, Projec return; } - string typeName = classType.Name?.Value ?? string.Empty; + string typeName = classType.GetRawName(); // Emit the factory objref + IIDs at the top so the parameterized ctors can reference it. if (composableType.Methods.Count > 0) diff --git a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs index 4f7c98d22..34b7eee2d 100644 --- a/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/CustomAttributeFactory.cs @@ -314,7 +314,7 @@ internal static void WritePlatformAttributeBody(IndentedTextWriter writer, Proje continue; } - string name = attrType.Name?.Value ?? string.Empty; + string name = attrType.GetRawName(); if (name.EndsWith("Attribute", StringComparison.Ordinal)) { diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index cea063667..867d3212a 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -237,10 +237,10 @@ public static void WriteInterfaceMemberSignatures(IndentedTextWriter writer, Pro // name exists on a base interface (typically the getter-only counterpart). This hides // the inherited member. string newKeyword = (getter is null && setter is not null - && TryFindPropertyInBaseInterfaces(context.Cache, type, prop.Name?.Value ?? string.Empty, out _)) + && TryFindPropertyInBaseInterfaces(context.Cache, type, prop.GetRawName(), out _)) ? "new " : string.Empty; string propType = WritePropType(context, prop); - writer.Write($"{newKeyword}{propType} {prop.Name?.Value} {{"); + writer.Write($"{newKeyword}{propType} {prop.GetRawName()} {{"); writer.WriteIf(getter is not null || setter is not null, " get;"); @@ -302,7 +302,7 @@ private static bool TryFindPropertyInBaseInterfacesRecursive(MetadataCache cache foreach (PropertyDefinition prop in baseIface.Properties) { - if ((prop.Name?.Value ?? string.Empty) == propName) + if (prop.GetRawName() == propName) { foundInterface = baseIface; return true; diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 22acee0b0..75f5be10a 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -241,7 +241,7 @@ public static void Dispose({{abi}} value) && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd3)) { // Nested non-blittable struct: dispose via its Marshaller. - string nestedNs = fieldStructTd3.Namespace?.Value ?? string.Empty; + string nestedNs = fieldStructTd3.Names().Namespace; string nestedNm = fieldStructTd3.GetStrippedName(); writer.WriteLine($"global::ABI.{nestedNs}.{nestedNm}Marshaller.Dispose(value.{fname});"); } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index 0ba5a2b96..eba0ec765 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -184,7 +184,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe foreach (TypeDefinition facType in factoryInterfacesAllNs) { // Only consider factory interfaces in the same namespace as we're processing. - string facNs = facType.Namespace?.Value ?? string.Empty; + string facNs = facType.Names().Namespace; if (facNs == ns) { diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 33e38a4ea..202d05724 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -140,8 +140,7 @@ public static string GetAbiStructTypeName(ProjectionEmitContext context, TypeSig { if (sig is TypeDefOrRefSignature td) { - string ns = td.Type?.Namespace?.Value ?? string.Empty; - string name = td.Type?.Name?.Value ?? string.Empty; + (string ns, string name) = td.Type.Names(); // If this struct is mapped, use the mapped namespace+name (e.g. // 'Windows.UI.Xaml.Interop.TypeName' is mapped to 'System.Type', so the ABI struct diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 5e1319b21..3ae431a21 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -79,8 +79,7 @@ internal static bool IsFieldTypeBlittable(MetadataCache cache, TypeSignature sig // For TypeRef/TypeDef, resolve and check blittability. if (sig is TypeDefOrRefSignature todr) { - string fNs = todr.Type?.Namespace?.Value ?? string.Empty; - string fName = todr.Type?.Name?.Value ?? string.Empty; + (string fNs, string fName) = todr.Type.Names(); // System.Guid is a fundamental blittable type . // Same applies to System.IntPtr / UIntPtr (used in some struct layouts). @@ -290,8 +289,7 @@ internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) // RequiresMarshaling, regardless of inner field layout. So for mapped types like // Duration, KeyTime, RepeatBehavior (RequiresMarshaling=false), they're never "complex". - string sNs = td.Type?.Namespace?.Value ?? string.Empty; - string sName = td.Type?.Name?.Value ?? string.Empty; + (string sNs, string sName) = td.Type.Names(); MappedType? sMapped = MappedTypes.Get(sNs, sName); if (sMapped is not null) @@ -360,8 +358,7 @@ internal static bool IsAnyStruct(MetadataCache cache, TypeSignature sig) // (only applies to actual structs, not mapped interfaces like IAsyncAction). if (TypeCategorization.GetCategory(def) == TypeCategory.Struct) { - string sNs = td.Type?.Namespace?.Value ?? string.Empty; - string sName = td.Type?.Name?.Value ?? string.Empty; + (string sNs, string sName) = td.Type.Names(); MappedType? sMapped = MappedTypes.Get(sNs, sName); if (sMapped is { } sMappedVal) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs index facefb4e5..2c6cd73e2 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Marshallers.cs @@ -27,8 +27,7 @@ internal static bool TryGetNullablePrimitiveMarshallerName(TypeSignature sig, ou } ITypeDefOrRef gt = gi.GenericType; - string ns = gt?.Namespace?.Value ?? string.Empty; - string name = gt?.Name?.Value ?? string.Empty; + (string ns, string name) = gt.Names(); // In WinMD metadata, Nullable is encoded as Windows.Foundation.IReference. // (It only later gets projected to System.Nullable by the projection layer.) @@ -140,8 +139,7 @@ internal static string GetMarshallerFullName(IndentedTextWriter writer, Projecti { if (sig is TypeDefOrRefSignature td) { - string ns = td.Type?.Namespace?.Value ?? string.Empty; - string name = td.Type?.Name?.Value ?? string.Empty; + (string ns, string name) = td.Type.Names(); // Apply mapped type remapping (e.g. System.Uri -> Windows.Foundation.Uri) _ = MappedTypes.ApplyMapping(ref ns, ref name); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index d1b29a368..1ba970535 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -230,8 +230,10 @@ public static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) return true; } - return (a.Namespace?.Value ?? string.Empty) == (b.Namespace?.Value ?? string.Empty) - && (a.Name?.Value ?? string.Empty) == (b.Name?.Value ?? string.Empty); + (string aNs, string aName) = a.Names(); + (string bNs, string bName) = b.Names(); + + return aNs == bNs && aName == bName; } } diff --git a/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs b/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs index 2e1dbf94e..814b642f5 100644 --- a/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/AttributedTypes.cs @@ -70,7 +70,7 @@ public static IEnumerable> Get(TypeDefiniti continue; } - string key = info.Type?.Name?.Value ?? string.Empty; + string key = info.Type?.GetRawName() ?? string.Empty; result[key] = info; } diff --git a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs index c0dfb2ad2..2349f569a 100644 --- a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs +++ b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs @@ -137,7 +137,7 @@ private void SortMembersByName() { foreach (NamespaceMembers members in _namespaces.Values) { - static int Compare(TypeDefinition a, TypeDefinition b) => StringComparer.Ordinal.Compare(a.Name?.Value ?? string.Empty, b.Name?.Value ?? string.Empty); + static int Compare(TypeDefinition a, TypeDefinition b) => StringComparer.Ordinal.Compare(a.GetRawName(), b.GetRawName()); members.Types.Sort(Compare); members.Interfaces.Sort(Compare); members.Classes.Sort(Compare); From 8d07e7a8263ad183de2695cf83b15d49d6a74a87 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:38:34 -0700 Subject: [PATCH 151/171] Dedupe types using FullName and CollectionsMarshal Simplify and optimize type deduplication: use TypeDefinition.FullName instead of manually concatenating namespace/name, and use CollectionsMarshal.GetValueRefOrAddDefault to avoid a double dictionary lookup when creating NamespaceMembers. Adds System.Runtime.InteropServices import and initializes NamespaceMembers via ref with null-coalescing assignment. Preserves first-load-wins semantics for conflicting WinMD types. --- .../Metadata/MetadataCache.cs | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs index 2349f569a..66e28b53e 100644 --- a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs +++ b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Runtime.InteropServices; using AsmResolver.DotNet; using WindowsRuntime.ProjectionWriter.Errors; @@ -138,6 +139,7 @@ private void SortMembersByName() foreach (NamespaceMembers members in _namespaces.Values) { static int Compare(TypeDefinition a, TypeDefinition b) => StringComparer.Ordinal.Compare(a.GetRawName(), b.GetRawName()); + members.Types.Sort(Compare); members.Interfaces.Sort(Compare); members.Classes.Sort(Compare); @@ -172,22 +174,17 @@ private void LoadFile(string path) } // Dedupe by full type name. Multiple input .winmd files can legitimately define types - // with the same full name (e.g. WindowsRuntime.Internal types appearing in both - // WindowsRuntime.Internal.winmd and cswinrt.winmd, or types showing up in both an SDK - // contract winmd and a 3rd-party WinMD that re-exports / forwards them). First-load-wins. - string fullName = string.IsNullOrEmpty(ns) ? name : ns + "." + name; - - if (!_typesByFullName.TryAdd(fullName, type)) + // with the same full name (e.g. types showing up in both an SDK contract winmd and a + // 3rd-party WinMD that re-exports / forwards them). First-load-wins. + if (!_typesByFullName.TryAdd(type.FullName, type)) { continue; } - if (!_namespaces.TryGetValue(ns, out NamespaceMembers? members)) - { - members = new NamespaceMembers(ns); - _namespaces[ns] = members; - } + // Avoid the double lookup: just add a default entry and initialize it here if needed + ref NamespaceMembers? members = ref CollectionsMarshal.GetValueRefOrAddDefault(_namespaces, ns, out _); + members ??= new NamespaceMembers(ns); members.AddType(type); _typeToModulePath[type] = moduleFilePath; From fd32e954a30ff9fdbfded0761961fabab07d647d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:40:55 -0700 Subject: [PATCH 152/171] Simplify InterfacesEqualByName implementation Replace the verbose reference and name comparison in InterfacesEqualByName with a single return using tuple equality: return a == b || a.Names() == b.Names(); This preserves the original behavior (true for identical references or matching namespace/name tuples) while making the code more concise and readable. --- src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 1ba970535..2a94ba726 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -225,15 +225,7 @@ public static int GetClassHierarchyIndex(MetadataCache cache, TypeDefinition cla /// public static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) { - if (a == b) - { - return true; - } - - (string aNs, string aName) = a.Names(); - (string bNs, string bName) = b.Names(); - - return aNs == bNs && aName == bName; + return a == b || a.Names() == b.Names(); } } From a2ad8cc95c674edf750bbb1ebe79512fec2e31a7 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:43:49 -0700 Subject: [PATCH 153/171] Use GetRawNamespace to avoid allocations Add ITypeDescriptorExtensions.GetRawNamespace to return the raw metadata namespace (falling back to string.Empty) and document it as a cheaper alternative to the Names tuple when only the namespace is needed. Replace calls to type.Names().Namespace with type.GetRawNamespace() across multiple factories and the generator to avoid allocating the name string unnecessarily. Also include a small doc-comment tweak for GetRawName. Modified files: ITypeDescriptorExtensions.cs, AbiClassFactory.cs, AbiDelegateFactory.cs, AbiInterfaceFactory.cs, StructEnumMarshallerFactory.cs, ProjectionGenerator.Namespace.cs. --- .../Extensions/ITypeDescriptorExtensions.cs | 14 ++++++++++++-- .../Factories/AbiClassFactory.cs | 6 +++--- .../Factories/AbiDelegateFactory.cs | 4 ++-- .../Factories/AbiInterfaceFactory.cs | 4 ++-- .../Factories/StructEnumMarshallerFactory.cs | 2 +- .../Generation/ProjectionGenerator.Namespace.cs | 2 +- 6 files changed, 21 insertions(+), 11 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs index e2697a982..2dece050d 100644 --- a/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ITypeDescriptorExtensions.cs @@ -23,10 +23,20 @@ internal static class ITypeDescriptorExtensions return (type.Namespace ?? string.Empty, type.Name ?? string.Empty); } + /// + /// Returns the type's raw metadata namespace, falling back to when + /// the metadata namespace is . More efficient than the + /// tuple when only the namespace is needed (avoids allocating the name ). + /// + public string GetRawNamespace() + { + return type.Namespace ?? string.Empty; + } + /// /// Returns the type's raw metadata name, falling back to when - /// the metadata name is . More efficient than the Names tuple - /// when only the name is needed (avoids allocating the namespace string). + /// the metadata name is . More efficient than the + /// tuple when only the name is needed (avoids allocating the namespace ). /// public string GetRawName() { diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 37b7dcbe3..af4b7e92b 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -49,7 +49,7 @@ public static void WriteAbiClass(IndentedTextWriter writer, ProjectionEmitContex internal static void WriteComponentClassMarshaller(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Names().Namespace; + string typeNs = type.GetRawNamespace(); string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); @@ -115,7 +115,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{projectedT internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Names().Namespace; + string typeNs = type.GetRawNamespace(); string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; TypeCategory category = TypeCategorization.GetCategory(type); @@ -199,7 +199,7 @@ public static bool EmitImplType(IndentedTextWriter writer, ProjectionEmitContext internal static void WriteClassMarshallerStub(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Names().Namespace; + string typeNs = type.GetRawNamespace(); string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); // Get the IID expression for the default interface (used by CreateObject). diff --git a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs index 5b4b066c9..50bfa7e1b 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiDelegateFactory.cs @@ -312,7 +312,7 @@ public EventState(void* thisPtr, int index) private static void WriteDelegateMarshallerOnly(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Names().Namespace; + string typeNs = type.GetRawNamespace(); string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); @@ -345,7 +345,7 @@ public static WindowsRuntimeObjectReferenceValue ConvertToUnmanaged({{fullProjec private static void WriteDelegateComWrappersCallback(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - string typeNs = type.Names().Namespace; + string typeNs = type.GetRawNamespace(); string fullProjected = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string iidExpr = ObjRefNameGenerator.WriteIidExpression(context, type).Format(); diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index c2b9b3b81..3ffdf174c 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -314,7 +314,7 @@ public static nint Vtable if (exclusiveToOwner is not null && !exclusiveIsFactoryOrStatic) { - string ownerNs = exclusiveToOwner.Names().Namespace; + string ownerNs = exclusiveToOwner.GetRawNamespace(); string ownerNm = exclusiveToOwner.GetStrippedName(); ifaceFullName = string.IsNullOrEmpty(ownerNs) ? GlobalPrefix + ownerNm @@ -324,7 +324,7 @@ public static nint Vtable { // Factory/static interfaces in authoring mode are implemented by the generated // 'global::ABI.Impl..' type that the activation factory CCW exposes. - string ifaceNs = type.Names().Namespace; + string ifaceNs = type.GetRawNamespace(); string ifaceNm = type.GetStrippedName(); ifaceFullName = string.IsNullOrEmpty(ifaceNs) ? "global::ABI.Impl." + ifaceNm diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 75f5be10a..db7380928 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -241,7 +241,7 @@ public static void Dispose({{abi}} value) && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd3)) { // Nested non-blittable struct: dispose via its Marshaller. - string nestedNs = fieldStructTd3.Names().Namespace; + string nestedNs = fieldStructTd3.GetRawNamespace(); string nestedNm = fieldStructTd3.GetStrippedName(); writer.WriteLine($"global::ABI.{nestedNs}.{nestedNm}Marshaller.Dispose(value.{fname});"); } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index eba0ec765..31917c283 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -184,7 +184,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe foreach (TypeDefinition facType in factoryInterfacesAllNs) { // Only consider factory interfaces in the same namespace as we're processing. - string facNs = facType.Names().Namespace; + string facNs = facType.GetRawNamespace(); if (facNs == ns) { From 2f57b5a26bda6db8d27c8e0fa864b4217a84f060 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:44:42 -0700 Subject: [PATCH 154/171] Remove ArrayParameters and HasParameterOfCategory Delete two helper methods from MethodSignatureInfoExtensions: ArrayParameters (which yielded parameters whose resolved category was an array shape: PassArray/FillArray/ReceiveArray) and HasParameterOfCategory (which checked whether any parameter had a given ParameterCategory). This simplifies the class by removing these utilities; update callers to use ParameterCategoryResolver or other logic as needed. --- .../Models/MethodSignatureInfoExtensions.cs | 34 ------------------- 1 file changed, 34 deletions(-) diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs index 7dda551a6..136dd2795 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureInfoExtensions.cs @@ -46,39 +46,5 @@ internal static class MethodSignatureInfoExtensions } } } - - /// - /// Yields each (index, parameter, category) triple whose resolved category is one of - /// the array shapes (, - /// , ). - /// - public IEnumerable<(int Index, ParameterInfo Parameter, ParameterCategory Category)> ArrayParameters() - { - for (int i = 0; i < sig.Parameters.Count; i++) - { - ParameterInfo p = sig.Parameters[i]; - ParameterCategory cat = ParameterCategoryResolver.Resolve(p); - - if (cat.IsAnyArray()) - { - yield return (i, p, cat); - } - } - } - - /// - /// Returns whether any parameter has the given . - /// - public bool HasParameterOfCategory(ParameterCategory category) - { - for (int i = 0; i < sig.Parameters.Count; i++) - { - if (ParameterCategoryResolver.Resolve(sig.Parameters[i]) == category) - { - return true; - } - } - return false; - } } } From fef9c5a487b7f6a5055e62ceab15e3f149207708 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:45:52 -0700 Subject: [PATCH 155/171] Remove obsolete class modifier and fast-abi helper Delete unused helper methods WriteClassModifiers and IsFastAbiDefaultInterface from ClassFactory.cs, along with the related comment about the fast-abi flag. This cleans up dead code and removes redundant fast-abi handling no longer required by the projection writer. --- .../Factories/ClassFactory.cs | 33 ------------------- 1 file changed, 33 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index a8519bb43..6f99e4026 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -36,20 +36,6 @@ public static bool IsFastAbiClass(TypeDefinition type) return type.HasWindowsFoundationMetadataAttribute(FastAbiAttribute); } - /// - /// Writes the class modifiers ('static '/'sealed '). - /// - public static void WriteClassModifiers(IndentedTextWriter writer, TypeDefinition type) - { - if (TypeCategorization.IsStatic(type)) - { - writer.Write("static "); - return; - } - - writer.WriteIf(type.IsSealed, "sealed "); - } - /// /// Returns the fast-abi class type for if the interface is /// exclusive_to a class marked [FastAbi]; otherwise null. @@ -118,25 +104,6 @@ public static bool IsFastAbiOtherInterface(MetadataCache cache, TypeDefinition i return false; } - /// - /// Returns true if is the default interface of a fast-abi class. - /// - public static bool IsFastAbiDefaultInterface(MetadataCache cache, TypeDefinition iface) - { - (TypeDefinition Class, TypeDefinition? Default, List Others)? fastAbi = GetFastAbiClassForInterface(cache, iface); - - if (fastAbi is null) - { - return false; - } - - return fastAbi.Value.Default is not null && AbiTypeHelpers.InterfacesEqualByName(fastAbi.Value.Default, iface); - } - - // We don't have direct access to the active Settings from a static helper that only takes - // a TypeDefinition. The fast-abi flag is purely determined by the [FastAbiAttribute] (the - // netstandard_compat gate is always false in CsWinRT 3.0 -- the flag has been removed). - /// /// Returns the [Default] interface and the [ExclusiveTo] interfaces (sorted) for fast ABI. /// From 490787a9c22e5161e8b5fa87bbab1eef60d25aa3 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 14:51:10 -0700 Subject: [PATCH 156/171] Reference-projection events & static factory Emit different code paths when Settings.ReferenceProjection is enabled. For events, generate throw-null add/remove accessors in reference projection, otherwise generate subscription/unsubscription calls to the ABI event. For static factory object refs, emit a single expression-bodied throw-null property for reference projection, and preserve the previous activation-factory getter (with IID lookup) for the non-reference case. Also refactors multiline writer usage and cleans up surrounding formatting. --- .../Factories/ClassFactory.cs | 56 +++++++++---------- 1 file changed, 27 insertions(+), 29 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 6f99e4026..e3c634d29 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -321,21 +321,27 @@ public static void WriteStaticClassMembers(IndentedTextWriter writer, Projection writer.WriteIf(!string.IsNullOrEmpty(platformAttribute), platformAttribute); WriteEventTypeCallback eventType = TypedefNameWriter.WriteEventType(context, evt); - string accessors = context.Settings.ReferenceProjection - ? """ + + if (context.Settings.ReferenceProjection) + { + writer.WriteLine(isMultiline: true, $$""" + public static event {{eventType}} {{evtName}} + { add => throw null; remove => throw null; - """ - : $$""" + } + """); + } + else + { + writer.WriteLine(isMultiline: true, $$""" + public static event {{eventType}} {{evtName}} + { add => {{abiClass}}.{{evtName}}({{objRef}}, {{objRef}}).Subscribe(value); remove => {{abiClass}}.{{evtName}}({{objRef}}, {{objRef}}).Unsubscribe(value); - """; - writer.WriteLine(isMultiline: true, $$""" - public static event {{eventType}} {{evtName}} - { - {{accessors}} - } - """); + } + """); + } } // Properties (merge getter/setter across interfaces, tracking origin per accessor) @@ -454,25 +460,17 @@ public static event {{eventType}} {{evtName}} internal static void WriteStaticFactoryObjRef(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition staticIface, string runtimeClassFullName, string objRefName) { writer.WriteLine(); - writer.WriteLine(isMultiline: true, $$""" - private static WindowsRuntimeObjectReference {{objRefName}} - { - """); + if (context.Settings.ReferenceProjection) { - // the static factory objref getter body is just 'throw null;'. - writer.WriteLine(isMultiline: true, """ - get - { - throw null; - } - } - """); - return; + writer.WriteLine($"private static WindowsRuntimeObjectReference {objRefName} => throw null;"); } - WriteIidExpressionCallback iid = ObjRefNameGenerator.WriteIidExpression(context, staticIface); - writer.WriteLine(isMultiline: true, $$""" - get + else + { + WriteIidExpressionCallback iid = ObjRefNameGenerator.WriteIidExpression(context, staticIface); + + writer.WriteLine(isMultiline: true, $$""" + private static WindowsRuntimeObjectReference {{objRefName}} { var __{{objRefName}} = field; if (__{{objRefName}} != null && __{{objRefName}}.IsInCurrentContext) @@ -481,8 +479,8 @@ private static WindowsRuntimeObjectReference {{objRefName}} } return field = WindowsRuntimeObjectReference.GetActivationFactory("{{runtimeClassFullName}}", {{iid}}); } - } - """); + """); + } } /// From 851a8af9ada3c622953e124bc8a6395d98634bff Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 15:23:18 -0700 Subject: [PATCH 157/171] Remove dead code identified by multi-agent fleet analysis Four parallel analysis agents (claude-opus-4.7, claude-opus-4.6, gpt-5.5, gpt-5.3-codex) ran on src\WinRT.Projection.Writer\ to identify unused symbols. Findings were validated by greping each candidate across the full repo to confirm zero callers outside the cited definition. Deletions: - WellKnownProjectionWriterExceptions.InternalInvariantFailed (5001) and CannotResolveType (5002): both unreferenced (CannotResolveType's only caller was MetadataCache.FindRequired, which is itself unreferenced). - MetadataCache.FindRequired(string). - MappedTypes.HasNamespace(string). - AbiTypeHelpers.GetReturnLocalName. - MethodSignatureInfo.ReturnParameterName + cascading ProjectionNames.DefaultReturnParameterName constant. - TypeSemantics.BoundGenericParameter nested record (FundamentalTypes shape is unaffected; only the unused variant is removed). - TypeSemantics.FundamentalTypes.ToDotNetType helper. - IndentedTextWriter.GetSubstring(int, int). - IndentedTextWriter.FlushToString(). - TypeFilter.Empty static property and MatchesAllByDefault property. - ProjectionNames.VoidPointer constant. - WellKnownAbiTypeNames.AbiSystemExceptionPointerData, AbiSystemTypeMarshaller, AbiSystemExceptionMarshaller constants. - AbiTypeKindResolver.IsAnyStruct(TypeSignature) instance wrapper (the active AbiTypeHelpers.IsAnyStruct(MetadataCache, TypeSignature) static helper used by Resolve() stays). - TypeSignatureExtensions.SzArrayElement() extension (zero callers). - ParameterCategoryExtensions.IsAnyArray() extension (zero callers). - Drop now-unused 'using WindowsRuntime.ProjectionWriter.References;' from Models\MethodSignatureInfo.cs (was only there for DefaultReturnParameterName). 156 deletions total. Build clean with 0 warnings; validation harness reports 0 diffs across all 3 regen scenarios (pushnot, everything-with-ui, windows). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../WellKnownProjectionWriterExceptions.cs | 16 ---------- .../Extensions/ParameterCategoryExtensions.cs | 10 ------- .../Extensions/TypeSignatureExtensions.cs | 10 ------- .../Helpers/AbiTypeHelpers.cs | 9 ------ .../Helpers/MappedTypes.cs | 7 ----- .../Helpers/TypeFilter.cs | 11 ------- .../Metadata/MetadataCache.cs | 8 ----- .../Metadata/TypeSemantics.cs | 29 ------------------- .../Models/MethodSignatureInfo.cs | 9 ------ .../References/ProjectionNames.cs | 10 ------- .../References/WellKnownAbiTypeNames.cs | 9 ------ .../Resolvers/AbiTypeKindResolver.cs | 9 ------ .../Writers/IndentedTextWriter.cs | 19 ------------ 13 files changed, 156 deletions(-) diff --git a/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs b/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs index 5f914f12f..2fe94f53d 100644 --- a/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs +++ b/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs @@ -17,22 +17,6 @@ internal static class WellKnownProjectionWriterExceptions /// public const string ErrorPrefix = "CSWINRTPROJECTIONGEN"; - /// - /// An internal invariant about a referenced type failed. - /// - public static WellKnownProjectionWriterException InternalInvariantFailed(string message) - { - return Exception(5001, message); - } - - /// - /// A metadata type referenced from an emission helper could not be resolved. - /// - public static WellKnownProjectionWriterException CannotResolveType(string typeName) - { - return Exception(5002, $"The type '{typeName}' could not be resolved against the metadata cache."); - } - /// /// A switch over the well-known TypeCategory enum encountered an unrecognized member. /// diff --git a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs index 076c70595..ddb2f2200 100644 --- a/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/ParameterCategoryExtensions.cs @@ -32,15 +32,5 @@ public bool IsScalarInput() { return category is ParameterCategory.In or ParameterCategory.Ref; } - - /// - /// Returns whether the input category is any of the array-shaped categories - /// (, , - /// or ). - /// - public bool IsAnyArray() - { - return category is ParameterCategory.PassArray or ParameterCategory.FillArray or ParameterCategory.ReceiveArray; - } } } diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 0b49add7c..8373fe038 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -196,16 +196,6 @@ public TypeSignature StripByRefAndCustomModifiers() { return sig.StripByRefAndCustomModifiers() as SzArrayTypeSignature; } - - /// - /// Returns the element type of the underlying SZ-array (after stripping byref + - /// custom modifiers), or if the underlying type is not an - /// . - /// - public TypeSignature? SzArrayElement() - { - return (sig.StripByRefAndCustomModifiers() as SzArrayTypeSignature)?.BaseType; - } } extension([NotNullWhen(true)] TypeSignature? sig) diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 2a94ba726..0aed288ac 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -75,15 +75,6 @@ public static string GetReturnParamName(MethodSignatureInfo sig) return IdentifierEscaping.EscapeIdentifier(n); } - /// - /// Returns the local-variable name for the return parameter on the server side. - /// abi_marshaler::get_marshaler_local() which prefixes __ to the param name. - /// - public static string GetReturnLocalName(MethodSignatureInfo sig) - { - return "__" + GetReturnParamName(sig); - } - /// /// Returns '__<returnName>Size' — by default '____return_value__Size' for the standard '__return_value__' return param. /// diff --git a/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs b/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs index 8e928c65a..fc15169eb 100644 --- a/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs +++ b/src/WinRT.Projection.Writer/Helpers/MappedTypes.cs @@ -282,13 +282,6 @@ internal static class MappedTypes return null; } - /// - /// Returns whether contains at least one mapped type. - /// - /// The Windows Runtime namespace. - /// if there is at least one mapping in this namespace. - public static bool HasNamespace(string typeNamespace) => TypeMappings.ContainsKey(typeNamespace); - /// /// Returns whether a mapping exists for the type identified by /// (, ). diff --git a/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs b/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs index 747820658..4fc9639a3 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypeFilter.cs @@ -16,12 +16,6 @@ internal sealed class TypeFilter private readonly List _include; private readonly List _exclude; - /// - /// Gets a default that has no include and no exclude rules - /// (and therefore matches every type). - /// - public static TypeFilter Empty { get; } = new([], []); - /// /// Initializes a new with the given include and exclude prefix lists. /// @@ -33,11 +27,6 @@ public TypeFilter(IEnumerable include, IEnumerable exclude) _exclude = [.. exclude.OrderByDescending(s => s.Length)]; } - /// - /// Whether this filter matches everything by default (no include rules). - /// - public bool MatchesAllByDefault => _include.Count == 0; - /// /// Returns whether the given type name passes the include/exclude filter. /// Rules are sorted by descending prefix length (with includes winning ties over excludes); diff --git a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs index 66e28b53e..7a93c28f2 100644 --- a/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs +++ b/src/WinRT.Projection.Writer/Metadata/MetadataCache.cs @@ -224,12 +224,4 @@ public string GetSourcePath(TypeDefinition type) (string ns, string name) = type.Names(); return Find(ns, name); } - - /// - /// Gets a type by full name, throwing if not found. - /// - public TypeDefinition FindRequired(string fullName) - { - return Find(fullName) ?? throw WellKnownProjectionWriterExceptions.CannotResolveType(fullName); - } } diff --git a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs index f6de8fb04..6a71dd146 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs @@ -116,12 +116,6 @@ public sealed record GenericTypeIndex(int Index) : TypeSemantics; /// The zero-based parameter index. public sealed record GenericMethodIndex(int Index) : TypeSemantics; - /// - /// A bound generic parameter token (rare; appears in nested generics). - /// - /// The generic parameter. - public sealed record BoundGenericParameter(GenericParameter Parameter) : TypeSemantics; - /// /// A reference to a type defined in another assembly. /// @@ -301,27 +295,4 @@ internal static class FundamentalTypes _ => "object" }; - /// - /// Returns the .NET reflection short name for (e.g. "Int32", - /// "String"), or "Object" for unrecognized cases. - /// - /// The fundamental type to format. - /// The .NET reflection short name. - public static string ToDotNetType(FundamentalType t) => t switch - { - FundamentalType.Boolean => "Boolean", - FundamentalType.Char => "Char", - FundamentalType.Int8 => "SByte", - FundamentalType.UInt8 => "Byte", - FundamentalType.Int16 => "Int16", - FundamentalType.UInt16 => "UInt16", - FundamentalType.Int32 => "Int32", - FundamentalType.UInt32 => "UInt32", - FundamentalType.Int64 => "Int64", - FundamentalType.UInt64 => "UInt64", - FundamentalType.Float => "Single", - FundamentalType.Double => "Double", - FundamentalType.String => "String", - _ => "Object" - }; } diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs index b83f5dfa8..959b3d10f 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureInfo.cs @@ -6,7 +6,6 @@ using AsmResolver.DotNet; using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; -using WindowsRuntime.ProjectionWriter.References; namespace WindowsRuntime.ProjectionWriter.Models; @@ -93,14 +92,6 @@ public MethodSignatureInfo(MethodDefinition method, GenericContext? genericConte } } - /// - /// Returns the name of the return parameter, or if there is none. - /// - /// The default name to use when no return parameter is declared. - /// The return parameter name (or default). - public string ReturnParameterName(string defaultName = ProjectionNames.DefaultReturnParameterName) - => ReturnParameter?.Name?.Value ?? defaultName; - /// /// Bundles the three derived return-parameter names commonly needed during marshalling code /// emission: diff --git a/src/WinRT.Projection.Writer/References/ProjectionNames.cs b/src/WinRT.Projection.Writer/References/ProjectionNames.cs index 39318e768..b2a893911 100644 --- a/src/WinRT.Projection.Writer/References/ProjectionNames.cs +++ b/src/WinRT.Projection.Writer/References/ProjectionNames.cs @@ -44,14 +44,4 @@ internal static class ProjectionNames /// public const string IID = "IID"; - /// - /// The C# void-pointer keyword form ("void*"). - /// - public const string VoidPointer = "void*"; - - /// - /// The default placeholder name used for a method's return parameter when the - /// metadata does not declare one explicitly ("__return_value__"). - /// - public const string DefaultReturnParameterName = "__return_value__"; } diff --git a/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs b/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs index 75d77053d..9e3e92bb6 100644 --- a/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/References/WellKnownAbiTypeNames.cs @@ -22,18 +22,9 @@ internal static class WellKnownAbiTypeNames /// The global::ABI.System.Exception* pointer-to-ABI form. public const string AbiSystemExceptionPointer = "global::ABI.System.Exception*"; - /// The global::ABI.System.Exception* data parameter signature. - public const string AbiSystemExceptionPointerData = "global::ABI.System.Exception* data"; - /// The global::ABI.System.DateTimeOffset ABI helper struct. public const string AbiSystemDateTimeOffset = "global::ABI.System.DateTimeOffset"; /// The global::ABI.System.TimeSpan ABI helper struct. public const string AbiSystemTimeSpan = "global::ABI.System.TimeSpan"; - - /// The global::ABI.System.TypeMarshaller static class. - public const string AbiSystemTypeMarshaller = "global::ABI.System.TypeMarshaller"; - - /// The global::ABI.System.ExceptionMarshaller static class. - public const string AbiSystemExceptionMarshaller = "global::ABI.System.ExceptionMarshaller"; } diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index fdd6d6800..b00096e2d 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -138,15 +138,6 @@ public bool IsEnumType(TypeSignature signature) public bool IsBlittableStruct(TypeSignature signature) => Resolve(signature) == AbiTypeKind.BlittableStruct; - /// - /// Returns whether is any WinRT struct that flows across the ABI by value - /// (either a blittable struct or a complex struct that needs per-field marshalling). - /// - /// The type signature to classify. - /// if a struct; otherwise . - public bool IsAnyStruct(TypeSignature signature) - => Resolve(signature) is AbiTypeKind.BlittableStruct or AbiTypeKind.ComplexStruct; - /// /// Returns whether is a WinRT struct that has at least one reference-type /// field and therefore requires per-field marshalling via a *Marshaller class. diff --git a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs index c098adb36..261a923d9 100644 --- a/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs +++ b/src/WinRT.Projection.Writer/Writers/IndentedTextWriter.cs @@ -506,14 +506,6 @@ public void WriteLineIf(bool condition, bool isMultiline, ReadOnlySpan con /// public char Back() => _buffer.Length == 0 ? '\0' : _buffer[^1]; - /// - /// Returns the contents of a substring of the buffer (used for capture-and-restore patterns). - /// - /// The starting position. - /// The length of the substring to return. - /// The substring of the buffer at the requested position. - public string GetSubstring(int startIndex, int length) => _buffer.ToString(startIndex, length); - /// /// Removes a range of characters from the buffer. /// @@ -579,17 +571,6 @@ public void FlushToFile(string path) _ = _buffer.Clear(); } - /// - /// Flushes the current buffer contents to a string (without trimming) and clears the buffer. - /// - /// The full buffer contents, untrimmed. - public string FlushToString() - { - string text = _buffer.ToString(); - _ = _buffer.Clear(); - return text; - } - /// /// Writes raw text to the underlying buffer, prepending current indentation if positioned /// at the start of a new line. From 453c14dc942f7c9a8190596ce1e471596f82f4aa Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 16:49:56 -0700 Subject: [PATCH 158/171] Clarify blittable/complex struct classifiers and remove 'almost-blittable' terminology Restructure the struct classifiers in AbiTypeHelpers.Blittability.cs around two clear concepts (blittable vs complex), matching the model the interop generator already uses. Three problems addressed: 1. IsComplexStruct had two tags - one wrong ('any struct that can be passed directly across the ABI', which is the opposite of complex) and one right. Drop the wrong one and expand the correct one with a section listing exactly which fields disqualify a struct (string, object, runtime class, generic instance, marshalling-mapped, nested complex). 2. Remove the 'almost-blittable' terminology throughout the project. The concept doesn't exist - structs are either blittable (projected layout matches the ABI byte-for-byte) or they aren't. The interop generator's blittability check is the reference model: WindowsRuntimeExtensions.IsBlittable + IsManagedValueType. Updated comments in StructEnumMarshallerFactory.cs (4 sites), AbiMethodBodyFactory.DoAbi.cs (2 sites), AbiMethodBodyFactory.RcwCaller.cs (1 site), AbiTypeWriter.cs (1 site), and AbiTypeHelpers.Blittability.cs (3 sites). 3. Rename IsAnyStruct -> IsBlittableStruct. The old name suggested 'any struct type'; the implementation actually filters out structs whose fields would force per-field marshalling, i.e. it returns true exactly when the struct is blittable. New name matches AbiTypeKindResolver.IsBlittableStruct (the existing high-level wrapper) and AbiTypeKind.BlittableStruct (the kind it maps to). Also renamed the 'almostBlittable' local in StructEnumMarshallerFactory.WriteStructEnumMarshallerClass to 'blittableStruct' for consistency. Also fixed a dangling/partial comment in IsComplexStruct that started mid-sentence with 'RequiresMarshaling, regardless...' - rewrote it to explain the mapped-struct short-circuit clearly. Build clean with 0 warnings; validation harness reports 0 diffs across all 3 regen scenarios (pushnot, everything-with-ui, windows). No semantic changes - all renames are call-site mechanical and all other edits are XML doc and comment improvements. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Extensions/TypeSignatureExtensions.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 4 +- .../AbiMethodBodyFactory.RcwCaller.cs | 2 +- .../Factories/StructEnumMarshallerFactory.cs | 24 +++-- .../Helpers/AbiTypeHelpers.Blittability.cs | 91 ++++++++++++------- .../Helpers/AbiTypeWriter.cs | 8 +- .../Resolvers/AbiTypeKindResolver.cs | 2 +- 7 files changed, 82 insertions(+), 51 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 8373fe038..071fbb586 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -16,7 +16,7 @@ namespace WindowsRuntime.ProjectionWriter; /// /// /// Predicates that need cross-module type resolution (e.g. IsBlittablePrimitive -/// with cross-module enum lookup, IsAnyStruct, IsComplexStruct) live in +/// with cross-module enum lookup, IsBlittableStruct, IsComplexStruct) live in /// and the ; /// they are intentionally not included here. /// diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index b2f80ec39..0ec81a958 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -428,7 +428,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else if (context.AbiTypeKindResolver.IsBlittableStruct(uRef) || context.AbiTypeKindResolver.IsBlittablePrimitive(uRef) || context.AbiTypeKindResolver.IsEnumType(uRef)) { - // Blittable/almost-blittable: ABI layout matches projected layout. + // Blittable: ABI layout matches projected layout. writer.Write($"*{ptr}"); } else @@ -747,7 +747,7 @@ internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, Proj } else if (context.AbiTypeKindResolver.IsBlittableStruct(p.Type)) { - // Blittable / almost-blittable struct: pass directly (projected type == ABI type). + // Blittable struct: pass directly (projected type == ABI type). writer.Write(pname); } else if (context.AbiTypeKindResolver.IsEnumType(p.Type)) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 62c6363ee..4b28facab 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -887,7 +887,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // ABI-format buffer (_) which is separate from the user's Span; we need to // CopyToManaged_ to convert each ABI element back to the projected form and // store it in the user's Span.write_marshal_from_abi - // Blittable element types (primitives and almost-blittable structs) don't need this + // Blittable element types (primitives and blittable structs) don't need this // because the user's Span wraps the same memory the native side wrote to. foreach ((_, ParameterInfo p) in sig.ParametersByCategory(ParameterCategory.FillArray)) diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index db7380928..7b495643b 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -42,14 +42,18 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P string nameStripped = type.GetStrippedName(); TypeCategory cat = TypeCategorization.GetCategory(type); - // "Almost-blittable" includes blittable + bool/char fields. Excludes string/object fields. - // Use the same predicate as IsAnyStruct (which is now scoped to almost-blittable). + // A struct field is "blittable" when its projected and ABI layouts match (no per-field + // marshalling). Detect that via AbiTypeKindResolver.IsBlittableStruct: it returns true + // for self-mapped structs with RequiresMarshaling=false and for user structs whose + // fields are all blittable. TypeDefOrRefSignature sig = type.ToTypeSignature(false) is TypeDefOrRefSignature td2 ? td2 : null!; - bool almostBlittable = cat == TypeCategory.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); + bool blittableStruct = cat == TypeCategory.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); bool isEnum = cat == TypeCategory.Enum; - // Complex structs are non-almost-blittable structs with reference fields (string, object, etc.). - bool isComplexStruct = cat == TypeCategory.Struct && !almostBlittable; + // Complex structs are the remaining (non-blittable, non-mapped) structs that need a + // per-field marshaller class because at least one field is a reference type, generic + // instance, or marshalling-mapped value. + bool isComplexStruct = cat == TypeCategory.Struct && !blittableStruct; // Detect Nullable reference fields to determine whether the struct's BoxToUnmanaged // call needs CreateComInterfaceFlags.TrackerSupport . @@ -254,13 +258,13 @@ public static void Dispose({{abi}} value) writer.WriteLine("}"); } - // BoxToUnmanaged: same pattern for all (enum, almost-blittable, complex, mapped struct). + // BoxToUnmanaged: same pattern for all (enum, blittable struct, complex struct, mapped struct). // Truth uses CreateComInterfaceFlags.TrackerSupport when the struct has reference type // fields (Nullable, etc.) to avoid GC issues with the boxed managed object reference. // Mapped struct (Duration/KeyTime/etc.) variants always use None — the public projected // type still routes through this marshaller (it just lacks per-field // ConvertToUnmanaged/ConvertToManaged because the field layout doesn't match). - string boxFlags = (isEnum || almostBlittable || isComplexStruct) && hasReferenceFields ? "TrackerSupport" : "None"; + string boxFlags = (isEnum || blittableStruct || isComplexStruct) && hasReferenceFields ? "TrackerSupport" : "None"; WriteIidReferenceExpressionCallback boxIidRef = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(isMultiline: true, $$""" @@ -270,7 +274,7 @@ public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? v } """); - // UnboxToManaged: simple for almost-blittable and mapped structs; for complex, unbox to + // UnboxToManaged: simple for blittable and mapped structs; for complex, unbox to // ABI struct then ConvertToManaged. Mapped struct unboxes directly to projected type (no // per-field ConvertToManaged needed because the projected struct's field layout matches // the WinMD struct layout). @@ -300,11 +304,11 @@ public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? v // Emit the InterfaceEntriesImpl static class and the proper ComWrappersMarshallerAttribute // class derived from WindowsRuntimeComWrappersMarshallerAttribute (matches truth). - // For enums and almost-blittable structs, GetOrCreateComInterfaceForObject uses None. + // For enums and blittable structs, GetOrCreateComInterfaceForObject uses None. // For complex structs (with reference fields), it uses TrackerSupport. // For complex structs, CreateObject converts via the *Marshaller.ConvertToManaged after // unboxing to the ABI struct. - if (isEnum || almostBlittable || isComplexStruct) + if (isEnum || blittableStruct || isComplexStruct) { WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 3ae431a21..4f342da29 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -252,13 +252,23 @@ ElementType.R8 or return false; } - /// True for any struct type that can be passed directly across the WinRT ABI - /// (no per-field marshalling required). This includes blittable structs and "almost-blittable" - /// structs that have only primitive fields like bool/char (whose C# layout matches the WinRT ABI). - /// Excludes structs with reference type fields (string/object/runtime classes/etc.). - /// True for structs that have at least one reference type field (string, generic - /// instance Nullable<T>, etc.). These need per-field marshalling via the *Marshaller class - /// (ConvertToUnmanaged/ConvertToManaged/Dispose). + /// + /// Returns whether is a WinRT struct that needs per-field marshalling + /// via a generated *Marshaller class (ConvertToUnmanaged / ConvertToManaged + /// / Dispose). This is the inverse of restricted to + /// non-mapped structs. + /// + /// + /// A struct is "complex" iff: + /// + /// it is NOT custom-mapped (mapped structs use a hand-written ABI helper, not a + /// per-field marshaller); and + /// it has at least one instance field that is not a blittable primitive (or enum) + /// and not a nested blittable struct (i.e. a , , + /// runtime class, generic instance, custom-mapped marshalling field, or a nested + /// complex struct). + /// + /// internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) { if (sig is not TypeDefOrRefSignature td) @@ -280,25 +290,25 @@ internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) return false; } - TypeCategory cat = TypeCategorization.GetCategory(def); - - if (cat != TypeCategory.Struct) + if (TypeCategorization.GetCategory(def) != TypeCategory.Struct) { return false; } - // RequiresMarshaling, regardless of inner field layout. So for mapped types like - // Duration, KeyTime, RepeatBehavior (RequiresMarshaling=false), they're never "complex". + // Custom-mapped structs are short-circuited up front: they go through a hand-written + // ABI helper (not a per-field marshaller) regardless of inner field layout. Mapped + // structs like Duration / KeyTime / RepeatBehavior (RequiresMarshaling=false) are + // therefore never "complex". (string sNs, string sName) = td.Type.Names(); - MappedType? sMapped = MappedTypes.Get(sNs, sName); - if (sMapped is not null) + if (MappedTypes.Get(sNs, sName) is not null) { return false; } - // A struct is "complex" if it has any field that is not a blittable primitive nor an - // almost-blittable struct (i.e. has a string/object/Nullable/etc. field). + // A struct is "complex" if it has any field that is not a blittable primitive nor a + // (recursively) blittable struct — i.e. it has a string/object/runtime class/generic + // instance/marshalling-mapped/complex-nested-struct field. foreach (FieldDefinition field in def.Fields) { if (field.IsStatic || field.Signature is null) @@ -313,20 +323,36 @@ internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) continue; } - if (IsAnyStruct(cache, ft)) + if (IsBlittableStruct(cache, ft)) { continue; } return true; } + return false; } /// - /// Returns whether resolves to a struct type (mapped or user-defined). + /// Returns whether is a WinRT struct that flows across the ABI + /// by value with no per-field marshalling (the projected struct's memory layout matches + /// the ABI representation byte-for-byte). /// - internal static bool IsAnyStruct(MetadataCache cache, TypeSignature sig) + /// + /// A struct qualifies as blittable iff: + /// + /// it is custom-mapped with RequiresMarshaling=false (e.g. self-mapped XAML + /// structs such as Duration, KeyTime, RepeatBehavior); or + /// every instance field is itself a blittable primitive (or enum), or a nested + /// blittable struct. + /// + /// Reference-typed fields (, , runtime classes, + /// generic instances, nested complex structs, custom-mapped fields with + /// RequiresMarshaling=true such as TimeSpan or DateTimeOffset) all + /// disqualify the containing struct. Complex structs are handled by . + /// + internal static bool IsBlittableStruct(MetadataCache cache, TypeSignature sig) { if (sig is not TypeDefOrRefSignature td) { @@ -359,22 +385,20 @@ internal static bool IsAnyStruct(MetadataCache cache, TypeSignature sig) if (TypeCategorization.GetCategory(def) == TypeCategory.Struct) { (string sNs, string sName) = td.Type.Names(); - MappedType? sMapped = MappedTypes.Get(sNs, sName); - if (sMapped is { } sMappedVal) + if (MappedTypes.Get(sNs, sName) is MappedType mappedType) { - return !sMappedVal.RequiresMarshaling; + return !mappedType.RequiresMarshaling; } } - TypeCategory cat = TypeCategorization.GetCategory(def); - - if (cat != TypeCategory.Struct) + // If the type isn't a struct type, then by definition it isn't blittable + if (TypeCategorization.GetCategory(def) != TypeCategory.Struct) { return false; } - // Reject if any instance field is a reference type (string/object/runtime class/etc.). + // Reject if any instance field is a reference type (string/object/runtime class/etc.) foreach (FieldDefinition field in def.Fields) { if (field.IsStatic || field.Signature is null) @@ -384,28 +408,31 @@ internal static bool IsAnyStruct(MetadataCache cache, TypeSignature sig) TypeSignature ft = field.Signature.FieldType; + // 'string' and 'object' are the only primitive types that aren't blittable if (ft is CorLibTypeSignature corlibField) { - if (corlibField.ElementType is - ElementType.String or - ElementType.Object) - { return false; } + if (corlibField.ElementType is ElementType.String or ElementType.Object) + { + return false; + } + continue; } - // Recurse: nested struct must also pass IsAnyStruct, otherwise reject. + // Recurse: a nested struct must also be blittable, otherwise reject if (IsBlittablePrimitive(cache, ft)) { continue; } - if (IsAnyStruct(cache, ft)) + if (IsBlittableStruct(cache, ft)) { continue; } return false; } + return true; } } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 9bf39d487..f9a00473b 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -79,10 +79,10 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext TypeSignature dts = d.Type.ToTypeSignature(); - // "Almost-blittable" structs (with bool/char fields but no reference-type - // fields) can pass through using the projected type since the C# layout - // matches the WinRT ABI directly. Truly complex structs (with string/object/ - // Nullable fields) need the ABI struct. + // Blittable structs (whose projected layout matches the WinRT ABI + // representation, including ones with bool/char fields) can pass through + // using the projected type. Complex structs (with string/object/runtime-class/ + // Nullable/marshalling-mapped fields) need the ABI struct. if (context.AbiTypeKindResolver.IsBlittableStruct(dts)) { TypedefNameWriter.WriteTypedefName(writer, context, d.Type, TypedefNameType.Projected, true); diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index b00096e2d..30dc236a7 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -90,7 +90,7 @@ public AbiTypeKind Resolve(TypeSignature signature) return AbiTypeKind.ComplexStruct; } - if (AbiTypeHelpers.IsAnyStruct(Cache, signature)) + if (AbiTypeHelpers.IsBlittableStruct(Cache, signature)) { return AbiTypeKind.BlittableStruct; } From eb9bae2833e73c75d56a981d312c19934aa79dba Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 16:52:57 -0700 Subject: [PATCH 159/171] Rename ComplexStruct to NonBlittableStruct Replace the "ComplexStruct" terminology with "NonBlittableStruct" across the projection writer. Renamed enum members, resolver methods, helper functions, model fields, and related properties (AbiTypeKind, AbiArrayElementKind, IsNonBlittableStruct, MethodSignatureMarshallingFacts, etc.), and updated all call sites in AbiMethodBodyFactory, StructEnumMarshallerFactory, AbiTypeHelpers, and related files. This is a rename/refactor to clarify that these structs are non-blittable (require per-field marshalling); no functional logic changes were introduced beyond the identifier and comment updates. --- .../Extensions/TypeSignatureExtensions.cs | 2 +- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 12 +++--- .../AbiMethodBodyFactory.RcwCaller.cs | 38 +++++++++---------- .../Factories/StructEnumMarshallerFactory.cs | 18 ++++----- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 6 +-- .../Helpers/AbiTypeHelpers.Blittability.cs | 4 +- .../Models/AbiArrayElementKind.cs | 2 +- .../Models/AbiTypeKind.cs | 2 +- .../Models/MethodSignatureMarshallingFacts.cs | 26 ++++++------- .../Resolvers/AbiTypeKindResolver.cs | 20 +++++----- 10 files changed, 65 insertions(+), 65 deletions(-) diff --git a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs index 071fbb586..b98a20625 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeSignatureExtensions.cs @@ -16,7 +16,7 @@ namespace WindowsRuntime.ProjectionWriter; /// /// /// Predicates that need cross-module type resolution (e.g. IsBlittablePrimitive -/// with cross-module enum lookup, IsBlittableStruct, IsComplexStruct) live in +/// with cross-module enum lookup, IsBlittableStruct, IsNonBlittableStruct) live in /// and the ; /// they are intentionally not included here. /// diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index 0ec81a958..f46e5e109 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -28,7 +28,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection bool returnIsReceiveArrayDoAbi = rt is SzArrayTypeSignature retSzAbi && (context.AbiTypeKindResolver.IsBlittableAbiElement(retSzAbi.BaseType) || retSzAbi.BaseType.IsAbiArrayElementRefLike(context.AbiTypeKindResolver) - || context.AbiTypeKindResolver.IsComplexStruct(retSzAbi.BaseType)); + || context.AbiTypeKindResolver.IsNonBlittableStruct(retSzAbi.BaseType)); bool returnIsHResultExceptionDoAbi = rt is not null && rt.IsHResultException(); bool returnIsString = rt is not null && rt.IsString(); bool returnIsRefType = rt is not null && context.AbiTypeKindResolver.IsReferenceTypeOrGenericInstance(rt); @@ -291,7 +291,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string dataParamType; string dataCastExpr; - if (context.AbiTypeKindResolver.IsComplexStruct(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsNonBlittableStruct(szArr.BaseType)) { string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); dataParamType = abiStructName + "* data"; @@ -422,7 +422,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { writer.Write($"global::ABI.System.ExceptionMarshaller.ConvertToManaged(*{ptr})"); } - else if (context.AbiTypeKindResolver.IsComplexStruct(uRef)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(uRef)) { writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uRef)}.ConvertToManaged(*{ptr})"); } @@ -496,7 +496,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // the local managed value through Marshaller.ConvertToUnmanaged before // writing it into the *out ABI struct slot.write_marshal_from_managed //: "Marshaller.ConvertToUnmanaged(local)". - else if (context.AbiTypeKindResolver.IsComplexStruct(underlying)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(underlying)) { rhs = $"{AbiTypeHelpers.GetMarshallerFullName(writer, context, underlying)}.ConvertToUnmanaged(__{raw})"; } @@ -601,7 +601,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // System.Type return (server-side): convert managed System.Type to ABI Type struct. writer.WriteLine($"*{retParamName} = global::ABI.System.TypeMarshaller.ConvertToUnmanaged({retLocalName});"); } - else if (context.AbiTypeKindResolver.IsComplexStruct(rt)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(rt)) { // Complex struct return (server-side): convert managed struct to ABI struct via marshaller. writer.WriteLine($"*{retParamName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt)}.ConvertToUnmanaged({retLocalName});"); @@ -740,7 +740,7 @@ internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, Proj // System.Type input (server-side): convert ABI Type struct to System.Type. writer.Write($"global::ABI.System.TypeMarshaller.ConvertToManaged({pname})"); } - else if (context.AbiTypeKindResolver.IsComplexStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(p.Type)) { // Complex struct input (server-side): convert ABI struct to managed via marshaller. writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, p.Type)}.ConvertToManaged({pname})"); diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs index 4b28facab..c19b59e3f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.RcwCaller.cs @@ -44,7 +44,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec bool returnIsString = facts.ReturnIsString; bool returnIsRefType = facts.ReturnIsRefType; bool returnIsBlittableStruct = facts.ReturnIsBlittableStruct; - bool returnIsComplexStruct = facts.ReturnIsComplexStruct; + bool returnIsNonBlittableStruct = facts.ReturnIsNonBlittableStruct; bool returnIsReceiveArray = facts.ReturnIsReceiveArray; bool returnIsHResultException = facts.ReturnIsHResultException; @@ -74,7 +74,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append(WellKnownAbiTypeNames.AbiSystemTypePointer); } - else if (context.AbiTypeKindResolver.IsComplexStruct(uOut)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(uOut)) { _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, uOut)); _ = fp.Append('*'); } @@ -95,7 +95,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature uRef = p.Type.StripByRefAndCustomModifiers(); _ = fp.Append(", "); - if (context.AbiTypeKindResolver.IsComplexStruct(uRef)) + if (context.AbiTypeKindResolver.IsNonBlittableStruct(uRef)) { _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, uRef)); _ = fp.Append('*'); } @@ -144,7 +144,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } else { - _ = fp.Append(context.AbiTypeKindResolver.IsComplexStruct(p.Type) + _ = fp.Append(context.AbiTypeKindResolver.IsNonBlittableStruct(p.Type) ? AbiTypeHelpers.GetAbiStructTypeName(context, p.Type) : AbiTypeHelpers.GetAbiPrimitiveType(context.Cache, p.Type)); } @@ -179,7 +179,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { _ = fp.Append(AbiTypeHelpers.GetBlittableStructAbiType(context, rt!)); _ = fp.Append('*'); } - else if (returnIsComplexStruct) + else if (returnIsNonBlittableStruct) { _ = fp.Append(AbiTypeHelpers.GetAbiStructTypeName(context, rt!)); _ = fp.Append('*'); } @@ -301,7 +301,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); - if (!context.AbiTypeKindResolver.IsComplexStruct(pType)) + if (!context.AbiTypeKindResolver.IsNonBlittableStruct(pType)) { continue; } @@ -419,7 +419,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine($"{AbiTypeHelpers.GetBlittableStructAbiType(context, rt!)} __retval = default;"); } - else if (returnIsComplexStruct) + else if (returnIsNonBlittableStruct) { writer.WriteLine($"{AbiTypeHelpers.GetAbiStructTypeName(context, rt!)} __retval = default;"); } @@ -467,7 +467,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); - if (!context.AbiTypeKindResolver.IsComplexStruct(pType)) + if (!context.AbiTypeKindResolver.IsNonBlittableStruct(pType)) { continue; } @@ -533,7 +533,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec } // Emit typed fixed lines for Ref params. - // Skip Ref+ComplexStruct: those are marshalled via __local (no fixed needed) and + // Skip Ref+NonBlittableStruct: those are marshalled via __local (no fixed needed) and // passed as &__local at the call site (the is-value-type-in path). int typedFixedCount = 0; for (int i = 0; i < sig.Parameters.Count; i++) @@ -545,7 +545,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { TypeSignature uRefSkip = p.Type.StripByRefAndCustomModifiers(); - if (context.AbiTypeKindResolver.IsComplexStruct(uRefSkip)) + if (context.AbiTypeKindResolver.IsNonBlittableStruct(uRefSkip)) { continue; } @@ -730,7 +730,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec dataParamType = WellKnownAbiTypeNames.AbiSystemExceptionPointer; dataCastType = "(global::ABI.System.Exception*)"; } - else if (context.AbiTypeKindResolver.IsComplexStruct(szArr.BaseType)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(szArr.BaseType)) { string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); dataParamType = abiStructName + "*"; @@ -805,7 +805,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string localName = p.GetParamLocalName(paramNameOverride); TypeSignature uRefArg = p.Type.StripByRefAndCustomModifiers(); - if (context.AbiTypeKindResolver.IsComplexStruct(uRefArg)) + if (context.AbiTypeKindResolver.IsNonBlittableStruct(uRefArg)) { // Complex struct 'in' (Ref) param: pass &__local (the marshaled ABI struct). writer.Write(isMultiline: true, $$""" @@ -849,7 +849,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec // Mapped value-type input: pass the pre-converted ABI local. writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); } - else if (context.AbiTypeKindResolver.IsComplexStruct(p.Type)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(p.Type)) { // Complex struct input: pass the pre-converted ABI struct local. writer.Write($"__{p.GetParamLocalName(paramNameOverride)}"); @@ -968,7 +968,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.Write($"global::ABI.System.TypeMarshaller.ConvertToManaged(__{localName})"); } - else if (context.AbiTypeKindResolver.IsComplexStruct(uOut)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(uOut)) { writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.ConvertToManaged(__{localName})"); } @@ -1096,7 +1096,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec writer.WriteLine("return __retval;"); } } - else if (returnIsComplexStruct) + else if (returnIsNonBlittableStruct) { writer.WriteLine($"return {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.ConvertToManaged(__retval);"); } @@ -1153,7 +1153,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec TypeSignature pType = p.Type.StripByRefAndCustomModifiers(); - if (!context.AbiTypeKindResolver.IsComplexStruct(pType)) + if (!context.AbiTypeKindResolver.IsNonBlittableStruct(pType)) { continue; } @@ -1252,7 +1252,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec string fixedPtrType; string disposeCastType; - if (context.AbiTypeKindResolver.IsComplexStruct(szArr.BaseType)) + if (context.AbiTypeKindResolver.IsNonBlittableStruct(szArr.BaseType)) { string abiStructName = AbiTypeHelpers.GetAbiStructTypeName(context, szArr.BaseType); disposeDataParamType = abiStructName + "*"; @@ -1314,7 +1314,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine($"global::ABI.System.TypeMarshaller.Dispose(__{localName});"); } - else if (context.AbiTypeKindResolver.IsComplexStruct(uOut)) + else if (context.AbiTypeKindResolver.IsNonBlittableStruct(uOut)) { writer.WriteLine($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, uOut)}.Dispose(__{localName});"); } @@ -1351,7 +1351,7 @@ internal static void EmitAbiMethodBodyIfSimple(IndentedTextWriter writer, Projec { writer.WriteLine("WindowsRuntimeUnknownMarshaller.Free(__retval);"); } - else if (returnIsComplexStruct) + else if (returnIsNonBlittableStruct) { writer.WriteLine($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, rt!)}.Dispose(__retval);"); } diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 7b495643b..a0b0f69e7 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -53,13 +53,13 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P // Complex structs are the remaining (non-blittable, non-mapped) structs that need a // per-field marshaller class because at least one field is a reference type, generic // instance, or marshalling-mapped value. - bool isComplexStruct = cat == TypeCategory.Struct && !blittableStruct; + bool isNonBlittableStruct = cat == TypeCategory.Struct && !blittableStruct; // Detect Nullable reference fields to determine whether the struct's BoxToUnmanaged // call needs CreateComInterfaceFlags.TrackerSupport . bool hasReferenceFields = false; - if (isComplexStruct) + if (isNonBlittableStruct) { foreach (FieldDefinition field in GetInstanceFields(type)) { @@ -78,11 +78,11 @@ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, P // public fields don't match the WinMD field layout. The truth marshaller for these // contains only BoxToUnmanaged/UnboxToManaged. (string typeNs, string typeNm) = type.Names(); - bool isMappedStruct = isComplexStruct && MappedTypes.Get(typeNs, typeNm) is not null; + bool isMappedStruct = isNonBlittableStruct && MappedTypes.Get(typeNs, typeNm) is not null; if (isMappedStruct) { - isComplexStruct = false; + isNonBlittableStruct = false; } WriteTypedefNameCallback abi = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, false); @@ -94,7 +94,7 @@ public static unsafe class {{nameStripped}}Marshaller """); writer.IncreaseIndent(); - if (isComplexStruct) + if (isNonBlittableStruct) { // ConvertToUnmanaged: build ABI struct from projected struct via per-field marshalling. writer.WriteLine(isMultiline: true, $$""" @@ -264,7 +264,7 @@ public static void Dispose({{abi}} value) // Mapped struct (Duration/KeyTime/etc.) variants always use None — the public projected // type still routes through this marshaller (it just lacks per-field // ConvertToUnmanaged/ConvertToManaged because the field layout doesn't match). - string boxFlags = (isEnum || blittableStruct || isComplexStruct) && hasReferenceFields ? "TrackerSupport" : "None"; + string boxFlags = (isEnum || blittableStruct || isNonBlittableStruct) && hasReferenceFields ? "TrackerSupport" : "None"; WriteIidReferenceExpressionCallback boxIidRef = ObjRefNameGenerator.WriteIidReferenceExpression(type); writer.WriteLine(isMultiline: true, $$""" @@ -278,7 +278,7 @@ public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? v // ABI struct then ConvertToManaged. Mapped struct unboxes directly to projected type (no // per-field ConvertToManaged needed because the projected struct's field layout matches // the WinMD struct layout). - if (isComplexStruct) + if (isNonBlittableStruct) { writer.WriteLine(isMultiline: true, $$""" public static {{projected}}? UnboxToManaged(void* value) @@ -308,7 +308,7 @@ public static WindowsRuntimeObjectReferenceValue BoxToUnmanaged({{projected}}? v // For complex structs (with reference fields), it uses TrackerSupport. // For complex structs, CreateObject converts via the *Marshaller.ConvertToManaged after // unboxing to the ABI struct. - if (isEnum || blittableStruct || isComplexStruct) + if (isEnum || blittableStruct || isNonBlittableStruct) { WriteIidReferenceExpressionCallback iidRefExpr = ObjRefNameGenerator.WriteIidReferenceExpression(type); @@ -370,7 +370,7 @@ public override object CreateObject(void* value, out CreatedWrapperFlags wrapper """); writer.IncreaseIndent(); writer.IncreaseIndent(); - if (isComplexStruct) + if (isNonBlittableStruct) { WriteTypedefNameCallback abiFq = TypedefNameWriter.WriteTypedefName(context, type, TypedefNameType.ABI, true); writer.WriteLine($"return {nameStripped}Marshaller.ConvertToManaged(WindowsRuntimeValueTypeMarshaller.UnboxToManagedUnsafe<{abiFq}>(value, in {iidRefExpr}));"); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 202d05724..f45682626 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -45,7 +45,7 @@ public static string GetAbiLocalTypeName(ProjectionEmitContext context, TypeSign return WellKnownAbiTypeNames.AbiSystemException; } - if (context.AbiTypeKindResolver.IsComplexStruct(sig)) + if (context.AbiTypeKindResolver.IsNonBlittableStruct(sig)) { return GetAbiStructTypeName(context, sig); } @@ -81,7 +81,7 @@ public static string GetArrayElementAbiType(ProjectionEmitContext context, TypeS AbiArrayElementKind.RefLikeVoidStar => "void*", AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, AbiArrayElementKind.MappedValueType => GetMappedAbiTypeName(elementType), - AbiArrayElementKind.ComplexStruct => GetAbiStructTypeName(context, elementType), + AbiArrayElementKind.NonBlittableStruct => GetAbiStructTypeName(context, elementType), AbiArrayElementKind.BlittableStruct => GetBlittableStructAbiType(context, elementType), _ => GetAbiPrimitiveType(context.Cache, elementType), }; @@ -102,7 +102,7 @@ public static string GetArrayElementStorageType(ProjectionEmitContext context, T return context.AbiTypeKindResolver.ClassifyArrayElement(elementType) switch { AbiArrayElementKind.MappedValueType => GetMappedAbiTypeName(elementType), - AbiArrayElementKind.ComplexStruct => GetAbiStructTypeName(context, elementType), + AbiArrayElementKind.NonBlittableStruct => GetAbiStructTypeName(context, elementType), AbiArrayElementKind.HResultException => WellKnownAbiTypeNames.AbiSystemException, _ => "nint", }; diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 4f342da29..9555f2a5a 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -269,7 +269,7 @@ ElementType.R8 or /// complex struct). /// /// - internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) + internal static bool IsNonBlittableStruct(MetadataCache cache, TypeSignature sig) { if (sig is not TypeDefOrRefSignature td) { @@ -350,7 +350,7 @@ internal static bool IsComplexStruct(MetadataCache cache, TypeSignature sig) /// Reference-typed fields (, , runtime classes, /// generic instances, nested complex structs, custom-mapped fields with /// RequiresMarshaling=true such as TimeSpan or DateTimeOffset) all - /// disqualify the containing struct. Complex structs are handled by . + /// disqualify the containing struct. Complex structs are handled by . /// internal static bool IsBlittableStruct(MetadataCache cache, TypeSignature sig) { diff --git a/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs b/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs index 745eb5905..4f2f61a48 100644 --- a/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs +++ b/src/WinRT.Projection.Writer/Models/AbiArrayElementKind.cs @@ -20,7 +20,7 @@ internal enum AbiArrayElementKind MappedValueType, /// The element is a complex struct (has reference-typed fields that require per-field marshalling). - ComplexStruct, + NonBlittableStruct, /// The element is a blittable struct (all fields are primitives or blittable structs). BlittableStruct, diff --git a/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs b/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs index 052ff047c..dd7fbd330 100644 --- a/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs +++ b/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs @@ -32,7 +32,7 @@ internal enum AbiTypeKind /// /// A WinRT struct with at least one reference-type field (string, generic instance, runtime class, etc.) that needs per-field marshalling via a generated *Marshaller. /// - ComplexStruct, + NonBlittableStruct, /// /// A WinRT struct that is mapped to a BCL value type and requires explicit marshalling (e.g. Windows.Foundation.DateTime -> ). diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index eaed251e4..f89eed5ae 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -16,27 +16,27 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// True when the return type is . /// True when the return type's shape is reference-typed (per ). /// True when the return type is a blittable struct. -/// True when the return type is a complex struct. +/// True when the return type is a complex struct. /// True when the return type is an SZ-array whose element is a known ABI element shape (blittable, ref-like, complex struct, HResult-exception, or mapped value type). /// True when the return type is (mapped from WinRT HResult). /// True when the return type is ; its ABI form holds an HSTRING that must be disposed. /// True when at least one Out parameter's underlying type carries a resource that requires post-call cleanup (ref-like array element, System.Type, complex struct, or generic instance). /// True when at least one parameter has ReceiveArray category. /// True when at least one parameter has Pass/Fill-array category and its element type is neither blittable nor mapped value type. -/// True when at least one In/Ref parameter's underlying type is a complex struct (needs marshaller initialisation). +/// True when at least one In/Ref parameter's underlying type is a complex struct (needs marshaller initialisation). internal readonly record struct MethodSignatureMarshallingFacts( AbiTypeKind ReturnShape, bool ReturnIsString, bool ReturnIsRefType, bool ReturnIsBlittableStruct, - bool ReturnIsComplexStruct, + bool ReturnIsNonBlittableStruct, bool ReturnIsReceiveArray, bool ReturnIsHResultException, bool ReturnIsSystemTypeForCleanup, bool HasOutNeedsCleanup, bool HasReceiveArray, bool HasNonBlittablePassArray, - bool HasComplexStructInput) + bool HasNonBlittableStructInput) { /// /// True when the emitted RCW-caller body must wrap the vtable call in a try/finally @@ -44,8 +44,8 @@ internal readonly record struct MethodSignatureMarshallingFacts( /// public bool NeedsTryFinally => ReturnIsString || ReturnIsRefType || ReturnIsReceiveArray || HasOutNeedsCleanup - || HasReceiveArray || ReturnIsComplexStruct || HasNonBlittablePassArray - || HasComplexStructInput || ReturnIsSystemTypeForCleanup; + || HasReceiveArray || ReturnIsNonBlittableStruct || HasNonBlittablePassArray + || HasNonBlittableStructInput || ReturnIsSystemTypeForCleanup; /// /// Computes the marshalling facts for using @@ -59,7 +59,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT bool returnIsString = returnShape == AbiTypeKind.String; bool returnIsRefType = returnShape.IsReferenceType(); bool returnIsBlittableStruct = returnShape == AbiTypeKind.BlittableStruct; - bool returnIsComplexStruct = returnShape == AbiTypeKind.ComplexStruct; + bool returnIsNonBlittableStruct = returnShape == AbiTypeKind.NonBlittableStruct; bool returnIsReceiveArray = rt is SzArrayTypeSignature retSz && resolver.IsRecognizedReceiveArrayElement(retSz.BaseType); bool returnIsHResultException = returnShape == AbiTypeKind.HResultException; @@ -68,7 +68,7 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT bool hasOutNeedsCleanup = false; bool hasReceiveArray = false; bool hasNonBlittablePassArray = false; - bool hasComplexStructInput = false; + bool hasNonBlittableStructInput = false; foreach ((_, ParameterInfo p, ParameterCategory cat) in sig.EnumerateWithCategory()) { @@ -90,10 +90,10 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT hasNonBlittablePassArray = true; } - if (!hasComplexStructInput && cat.IsScalarInput() - && resolver.IsComplexStruct(p.Type.StripByRefAndCustomModifiers())) + if (!hasNonBlittableStructInput && cat.IsScalarInput() + && resolver.IsNonBlittableStruct(p.Type.StripByRefAndCustomModifiers())) { - hasComplexStructInput = true; + hasNonBlittableStructInput = true; } } @@ -102,13 +102,13 @@ public static MethodSignatureMarshallingFacts From(MethodSignatureInfo sig, AbiT ReturnIsString: returnIsString, ReturnIsRefType: returnIsRefType, ReturnIsBlittableStruct: returnIsBlittableStruct, - ReturnIsComplexStruct: returnIsComplexStruct, + ReturnIsNonBlittableStruct: returnIsNonBlittableStruct, ReturnIsReceiveArray: returnIsReceiveArray, ReturnIsHResultException: returnIsHResultException, ReturnIsSystemTypeForCleanup: returnIsSystemTypeForCleanup, HasOutNeedsCleanup: hasOutNeedsCleanup, HasReceiveArray: hasReceiveArray, HasNonBlittablePassArray: hasNonBlittablePassArray, - HasComplexStructInput: hasComplexStructInput); + HasNonBlittableStructInput: hasNonBlittableStructInput); } } \ No newline at end of file diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index 30dc236a7..cbdd37276 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -85,9 +85,9 @@ public AbiTypeKind Resolve(TypeSignature signature) : AbiTypeKind.Enum; } - if (AbiTypeHelpers.IsComplexStruct(Cache, signature)) + if (AbiTypeHelpers.IsNonBlittableStruct(Cache, signature)) { - return AbiTypeKind.ComplexStruct; + return AbiTypeKind.NonBlittableStruct; } if (AbiTypeHelpers.IsBlittableStruct(Cache, signature)) @@ -144,8 +144,8 @@ public bool IsBlittableStruct(TypeSignature signature) /// /// The type signature to classify. /// if a complex struct; otherwise . - public bool IsComplexStruct(TypeSignature signature) - => Resolve(signature) == AbiTypeKind.ComplexStruct; + public bool IsNonBlittableStruct(TypeSignature signature) + => Resolve(signature) == AbiTypeKind.NonBlittableStruct; /// /// Returns whether is a WinRT runtime class, interface, or delegate @@ -203,7 +203,7 @@ public bool IsDirectPassArrayElement(TypeSignature signature) /// /// Blittable element (primitive or blittable struct) — see /// Ref-like (string / runtime class / interface / object) — see - /// Complex struct — see + /// Complex struct — see /// (mapped from WinRT HResult) — see /// Mapped value type (e.g. WinRT DateTime / TimeSpan) — see /// @@ -215,7 +215,7 @@ public bool IsDirectPassArrayElement(TypeSignature signature) public bool IsRecognizedReceiveArrayElement(TypeSignature signature) => IsBlittableAbiElement(signature) || signature.IsAbiArrayElementRefLike(this) - || IsComplexStruct(signature) + || IsNonBlittableStruct(signature) || signature.IsHResultException() || IsMappedAbiValueType(signature); @@ -226,7 +226,7 @@ public bool IsRecognizedReceiveArrayElement(TypeSignature signature) /// /// SZ-array element ref-like types (HSTRING / IInspectable* slots) — see /// (whose ABI form is an HSTRING that must be freed) — see - /// Complex structs (per-field cleanup via the *Marshaller) — see + /// Complex structs (per-field cleanup via the *Marshaller) — see /// Generic instances (need WindowsRuntimeObjectReferenceValue dispose) — see /// /// Callers should pass the already-stripped parameter type (via ). @@ -236,7 +236,7 @@ public bool IsRecognizedReceiveArrayElement(TypeSignature signature) public bool RequiresOutParameterCleanup(TypeSignature signature) => signature.IsAbiArrayElementRefLike(this) || signature.IsSystemType() - || IsComplexStruct(signature) + || IsNonBlittableStruct(signature) || signature.IsGenericInstance(); /// @@ -265,9 +265,9 @@ public AbiArrayElementKind ClassifyArrayElement(TypeSignature elementType) return AbiArrayElementKind.MappedValueType; } - if (IsComplexStruct(elementType)) + if (IsNonBlittableStruct(elementType)) { - return AbiArrayElementKind.ComplexStruct; + return AbiArrayElementKind.NonBlittableStruct; } if (IsBlittableStruct(elementType)) From fb1b820f6911a10dbe2229df0f03b20c2bbd6dfe Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 16:54:03 -0700 Subject: [PATCH 160/171] Use C# built-in type names in XML docs Replace fully-qualified BCL type names with C# keyword aliases (string, object) in XML documentation comments for consistency and readability. Changes touch TypeSemantics.cs, AbiTypeKind.cs, MethodSignatureMarshallingFacts.cs, and WellKnownTypeNames.cs. No runtime behavior changes. --- src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs | 8 ++++---- src/WinRT.Projection.Writer/Models/AbiTypeKind.cs | 2 +- .../Models/MethodSignatureMarshallingFacts.cs | 2 +- .../References/WellKnownTypeNames.cs | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs index 6a71dd146..67df65ddb 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeSemantics.cs @@ -12,7 +12,7 @@ namespace WindowsRuntime.ProjectionWriter.Metadata; /// /// Identifies a fundamental WinRT primitive type (those whose ABI representation matches a C# -/// primitive type, plus ). +/// primitive type, plus ). /// internal enum FundamentalType { @@ -52,7 +52,7 @@ internal enum FundamentalType /// . Double, - /// . + /// . String, } @@ -70,7 +70,7 @@ private TypeSemantics() { } public sealed record Fundamental(FundamentalType Type) : TypeSemantics; /// - /// The corlib type. + /// The corlib type. /// public sealed record ObjectType : TypeSemantics; @@ -153,7 +153,7 @@ public static TypeSemantics Get(TypeSignature signature) /// /// Resolves an into the corresponding . - /// Recognizes the special-cased corlib types (, , + /// Recognizes the special-cased corlib types (, , /// ) and falls back to / /// for everything else. /// diff --git a/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs b/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs index dd7fbd330..c73288e59 100644 --- a/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs +++ b/src/WinRT.Projection.Writer/Models/AbiTypeKind.cs @@ -40,7 +40,7 @@ internal enum AbiTypeKind MappedAbiValueType, /// - /// The corlib primitive (marshalled via HSTRING). + /// The corlib primitive (marshalled via HSTRING). /// String, diff --git a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs index f89eed5ae..13fe597bb 100644 --- a/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs +++ b/src/WinRT.Projection.Writer/Models/MethodSignatureMarshallingFacts.cs @@ -13,7 +13,7 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// needs to walk the parameter list once instead of re-deriving each flag inline. /// /// The resolved of the return type, or when the method returns void. -/// True when the return type is . +/// True when the return type is . /// True when the return type's shape is reference-typed (per ). /// True when the return type is a blittable struct. /// True when the return type is a complex struct. diff --git a/src/WinRT.Projection.Writer/References/WellKnownTypeNames.cs b/src/WinRT.Projection.Writer/References/WellKnownTypeNames.cs index 5293344e5..5e1435571 100644 --- a/src/WinRT.Projection.Writer/References/WellKnownTypeNames.cs +++ b/src/WinRT.Projection.Writer/References/WellKnownTypeNames.cs @@ -44,7 +44,7 @@ internal static class WellKnownTypeNames public const string Exception = "Exception"; /// - /// The BCL type name. + /// The BCL type name. /// public const string Object = "Object"; From 688c1e5b0aa398c31306f54255f1fcf9716507b1 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 16:56:13 -0700 Subject: [PATCH 161/171] Clarify ABI comments: 'non-blittable' and simplify Update comments in AbiMethodBodyFactory.DoAbi to use the term 'non-blittable structs' instead of 'complex structs' and remove redundant 'server-side' qualifiers. Also shorten several Nullable and System.Type comment lines for clarity and consistency. No functional code changes; only comment/text updates in src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs. --- .../Factories/AbiMethodBodyFactory.DoAbi.cs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs index f46e5e109..1d738a284 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiMethodBodyFactory.DoAbi.cs @@ -284,7 +284,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection string ptr = IdentifierEscaping.EscapeIdentifier(raw); WriteProjectionTypeCallback elementProjected = TypedefNameWriter.WriteProjectionType(context, TypeSemanticsFactory.Get(szArr.BaseType)); - // For complex structs, the data param is the ABI struct pointer (e.g. BasicStruct*). + // For non-blittable structs, the data param is the ABI struct pointer (e.g. BasicStruct*). // The Do_Abi parameter we receive is void* (per V3R3-M8), so the call-site needs an // explicit (T*) cast to bridge the type. For ref-types (string/runtime-class/object), // the data param is void** and the cast is (void**). @@ -320,7 +320,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection if (p.Type.IsNullableT()) { - // Nullable param (server-side): use Marshaller.UnboxToManaged. + // Nullable param: use Marshaller.UnboxToManaged. string rawName = p.GetRawName(); string callName = IdentifierEscaping.EscapeIdentifier(rawName); (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, p.Type); @@ -543,7 +543,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection // Determine the ABI element type for the data pointer cast (e.g. "void*" for // ref-like elements -> "void** data"/"(void**)", or "global::ABI.Foo.Bar" for - // complex structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). + // on-blittable structs -> "global::ABI.Foo.Bar* data"/"(global::ABI.Foo.Bar*)"). string elementAbi = AbiTypeHelpers.GetArrayElementAbiType(context, szFA.BaseType); writer.IncreaseIndent(); @@ -569,7 +569,7 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection { if (rt is not null && rt.IsNullableT()) { - // Nullable return (server-side): use Marshaller.BoxToUnmanaged. + // Nullable return: use Marshaller.BoxToUnmanaged. (_, string innerMarshaller) = AbiTypeHelpers.GetNullableInnerInfo(writer, context, rt); writer.WriteLine($"*{retParamName} = {innerMarshaller}.BoxToUnmanaged({retLocalName}).DetachThisPtrUnsafe();"); } @@ -598,12 +598,12 @@ internal static void EmitDoAbiBodyIfSimple(IndentedTextWriter writer, Projection } else if (rt.IsSystemType()) { - // System.Type return (server-side): convert managed System.Type to ABI Type struct. + // System.Type return: convert managed System.Type to ABI Type struct. writer.WriteLine($"*{retParamName} = global::ABI.System.TypeMarshaller.ConvertToUnmanaged({retLocalName});"); } else if (context.AbiTypeKindResolver.IsNonBlittableStruct(rt)) { - // Complex struct return (server-side): convert managed struct to ABI struct via marshaller. + // Non-blittable struct return: convert managed struct to ABI struct via marshaller. writer.WriteLine($"*{retParamName} = {AbiTypeHelpers.GetMarshallerFullName(writer, context, rt)}.ConvertToUnmanaged({retLocalName});"); } else if (returnIsBlittableStruct) @@ -737,12 +737,12 @@ internal static void EmitDoAbiParamArgConversion(IndentedTextWriter writer, Proj } else if (p.Type.IsSystemType()) { - // System.Type input (server-side): convert ABI Type struct to System.Type. + // System.Type input: convert ABI Type struct to System.Type. writer.Write($"global::ABI.System.TypeMarshaller.ConvertToManaged({pname})"); } else if (context.AbiTypeKindResolver.IsNonBlittableStruct(p.Type)) { - // Complex struct input (server-side): convert ABI struct to managed via marshaller. + // Non-blittable struct input: convert ABI struct to managed via marshaller. writer.Write($"{AbiTypeHelpers.GetMarshallerFullName(writer, context, p.Type)}.ConvertToManaged({pname})"); } else if (context.AbiTypeKindResolver.IsBlittableStruct(p.Type)) From 600e9cf6031ab8432a7301cb4a4839314d12c6fd Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 16:56:26 -0700 Subject: [PATCH 162/171] Fix comment punctuation in ConstructorFactory Remove an extraneous period in a comment inside src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs. This is a non-functional, cosmetic change to the comment "Sealed Invoke signature is multi-line" to match code style. --- .../Factories/ConstructorFactory.FactoryCallbacks.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs index 5e3d20d81..cad054c56 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.FactoryCallbacks.cs @@ -98,7 +98,7 @@ public override unsafe void Invoke( } else { - // Sealed Invoke signature is multi-line.. + // Sealed Invoke signature is multi-line writer.WriteLine(isMultiline: true, """ public override unsafe void Invoke( WindowsRuntimeActivationArgsReference additionalParameters, From 9d6c4da41b47e98ec79336a38de7dbd673ddf25d Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 17:00:26 -0700 Subject: [PATCH 163/171] Update phase comment in ProjectionGenerator Correct a comment in src/WinRT.Projection.Writer/Generation/ProjectionGenerator.cs: change "Phase 3..6: parallel emission" to "Phase 2: parallel emission" to accurately reflect the pipeline stage. No functional changes; this improves clarity for maintainers. --- src/WinRT.Projection.Writer/Generation/ProjectionGenerator.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.cs index 1fd63d248..c7b4cf374 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.cs @@ -70,7 +70,7 @@ public void Run() ProjectionGeneratorRunState state = new(componentActivatable, componentByModule); - // Phase 3..6: parallel emission. All file writes happen below; wrap the whole emission + // Phase 2: parallel emission. All file writes happen below; wrap the whole emission // pipeline in a single try/catch so any unexpected failure surfaces as an // UnhandledProjectionWriterException rather than a raw stack trace. try From 24b9cb0c0c469032e31987fc46dfeb61e372ec25 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Wed, 20 May 2026 17:10:28 -0700 Subject: [PATCH 164/171] Simplify type categorization with pattern matching Refactor GetCategory to use C# pattern matching on TypeDefinition (IsInterface, IsEnum, IsValueType, IsDelegate) instead of manual BaseType and namespace/name checks. Removes an unused 'using AsmResolver' and simplifies the method body without changing behavior (defaulting to TypeCategory.Class). --- .../Metadata/TypeCategorization.cs | 38 ++++--------------- 1 file changed, 7 insertions(+), 31 deletions(-) diff --git a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs index 3b4f4d660..96b00e362 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs @@ -1,7 +1,6 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -using AsmResolver; using AsmResolver.DotNet; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -30,37 +29,14 @@ internal static class TypeCategorization /// public static TypeCategory GetCategory(TypeDefinition type) { - if (type.IsInterface) + return type switch { - return TypeCategory.Interface; - } - - ITypeDefOrRef? baseType = type.BaseType; - - if (baseType is null) - { - return TypeCategory.Class; - } - - Utf8String? baseNs = baseType.Namespace; - Utf8String? baseName = baseType.Name; - - if (baseNs == "System" && baseName == "Enum") - { - return TypeCategory.Enum; - } - - if (baseNs == "System" && baseName == "ValueType") - { - return TypeCategory.Struct; - } - - if (baseNs == "System" && baseName == "MulticastDelegate") - { - return TypeCategory.Delegate; - } - - return TypeCategory.Class; + { IsInterface: true } => TypeCategory.Interface, + { IsEnum: true } => TypeCategory.Enum, + { IsValueType: true } => TypeCategory.Struct, + { IsDelegate: true } => TypeCategory.Delegate, + _ => TypeCategory.Class + }; } /// From f9426cb2e53a2aecd7f8a5baf8bc57e8ebd9cf85 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 11:14:53 -0700 Subject: [PATCH 165/171] Rename TypeCategory to TypeKind and move it under Models/ Mechanical rename of the type-categorization enum from 'TypeCategory' to 'TypeKind' and relocation from Metadata/TypeCategorization.cs to its own file Models/TypeKind.cs (alongside the other writer model enums - AbiTypeKind, ParameterCategory, AbiArrayElementKind, etc.). Updated the corresponding well-known exception helper 'UnknownTypeCategory' -> 'UnknownTypeKind' (and its error message), and added 'using WindowsRuntime.ProjectionWriter.Models;' to all 13 files that newly reference the relocated enum. TypeCategorization.GetCategory and the IsAttributeType / IsStatic / IsFlagsEnum / IsGeneric / IsApiContractType / IsExclusiveTo / IsProjectionInternal helpers are unchanged in behavior; they now reference TypeKind.X instead of TypeCategory.X internally. Build clean (0 warnings); validation harness reports 0 diffs across all 3 regen scenarios (pushnot, everything-with-ui, windows). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 36 +++++++++---------- .../WellKnownProjectionWriterExceptions.cs | 6 ++-- .../Factories/AbiClassFactory.cs | 9 ++--- .../Factories/AbiStructFactory.cs | 3 +- .../Factories/ComponentFactory.cs | 7 ++-- .../Factories/MetadataAttributeFactory.cs | 7 ++-- .../Factories/ReferenceImplFactory.cs | 9 ++--- .../Factories/StructEnumMarshallerFactory.cs | 17 ++++----- .../ProjectionGenerator.GeneratedIids.cs | 13 +++---- .../ProjectionGenerator.Namespace.cs | 25 ++++++------- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 +- .../Helpers/AbiTypeHelpers.Blittability.cs | 29 +++++++-------- .../Helpers/AbiTypeWriter.cs | 11 +++--- .../Helpers/SignatureGenerator.cs | 13 +++---- .../Helpers/TypedefNameWriter.cs | 3 +- .../Metadata/NamespaceMembers.cs | 13 +++---- .../Metadata/TypeCategorization.cs | 35 +++++++----------- .../Models/TypeKind.cs | 16 +++++++++ .../Resolvers/AbiTypeKindResolver.cs | 2 +- 19 files changed, 137 insertions(+), 119 deletions(-) create mode 100644 src/WinRT.Projection.Writer/Models/TypeKind.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 68692b054..72827b51f 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -23,61 +23,61 @@ internal static class ProjectionFileBuilder /// /// Dispatches type emission based on the type category. /// - public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeCategory category) + public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeKind category) { switch (category) { - case TypeCategory.Class when TypeCategorization.IsAttributeType(type): + case TypeKind.Class when TypeCategorization.IsAttributeType(type): WriteAttribute(writer, context, type); break; - case TypeCategory.Class: + case TypeKind.Class: ClassFactory.WriteClass(writer, context, type); break; - case TypeCategory.Delegate: + case TypeKind.Delegate: WriteDelegate(writer, context, type); break; - case TypeCategory.Enum: + case TypeKind.Enum: WriteEnum(writer, context, type); break; - case TypeCategory.Interface: + case TypeKind.Interface: InterfaceFactory.WriteInterface(writer, context, type); break; - case TypeCategory.Struct when TypeCategorization.IsApiContractType(type): + case TypeKind.Struct when TypeCategorization.IsApiContractType(type): WriteContract(writer, context, type); break; - case TypeCategory.Struct: + case TypeKind.Struct: WriteStruct(writer, context, type); break; default: - throw WellKnownProjectionWriterExceptions.UnknownTypeCategory(category); + throw WellKnownProjectionWriterExceptions.UnknownTypeKind(category); } } /// /// Dispatches ABI emission based on the type category. /// - public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeCategory category) + public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeKind category) { switch (category) { - case TypeCategory.Class: + case TypeKind.Class: AbiClassFactory.WriteAbiClass(writer, context, type); break; - case TypeCategory.Delegate: + case TypeKind.Delegate: AbiDelegateFactory.WriteAbiDelegate(writer, context, type); AbiDelegateFactory.WriteDelegateEventSourceSubclass(writer, context, type); break; - case TypeCategory.Enum: + case TypeKind.Enum: AbiEnumFactory.WriteAbiEnum(writer, context, type); break; - case TypeCategory.Interface: + case TypeKind.Interface: AbiInterfaceFactory.WriteAbiInterface(writer, context, type); break; - case TypeCategory.Struct: + case TypeKind.Struct: AbiStructFactory.WriteAbiStruct(writer, context, type); break; default: - throw WellKnownProjectionWriterExceptions.UnknownTypeCategory(category); + throw WellKnownProjectionWriterExceptions.UnknownTypeKind(category); } } @@ -162,11 +162,11 @@ private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext if (semantics is TypeSemantics.Definition d) { - isInterface = TypeCategorization.GetCategory(d.Type) == TypeCategory.Interface; + isInterface = TypeCategorization.GetCategory(d.Type) == TypeKind.Interface; } else if (semantics is TypeSemantics.GenericInstance gi) { - isInterface = TypeCategorization.GetCategory(gi.GenericType) == TypeCategory.Interface; + isInterface = TypeCategorization.GetCategory(gi.GenericType) == TypeKind.Interface; } fields.Add((fieldType, fieldName, paramName, isInterface)); diff --git a/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs b/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs index 2fe94f53d..c8224c10e 100644 --- a/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs +++ b/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs @@ -18,11 +18,11 @@ internal static class WellKnownProjectionWriterExceptions public const string ErrorPrefix = "CSWINRTPROJECTIONGEN"; /// - /// A switch over the well-known TypeCategory enum encountered an unrecognized member. + /// A switch over the well-known TypeKind enum encountered an unrecognized member. /// - public static WellKnownProjectionWriterException UnknownTypeCategory(object category) + public static WellKnownProjectionWriterException UnknownTypeKind(object kind) { - return Exception(5003, $"Unknown TypeCategory: {category}."); + return Exception(5003, $"Unknown TypeKind: {kind}."); } /// diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index af4b7e92b..d1fb12450 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -6,6 +6,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -118,24 +119,24 @@ internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, Proje string typeNs = type.GetRawNamespace(); string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; - TypeCategory category = TypeCategorization.GetCategory(type); + TypeKind category = TypeCategorization.GetCategory(type); // [WindowsRuntimeReferenceType(typeof(?))] for non-delegate, non-class types // (i.e. enums, structs, interfaces). - if (category is not (TypeCategory.Delegate or TypeCategory.Class)) + if (category is not (TypeKind.Delegate or TypeKind.Class)) { writer.WriteLine($"[WindowsRuntimeReferenceType(typeof({projectedType}?))]"); } // [ABI..ComWrappersMarshaller] for non-struct, non-class types // (delegates, enums, interfaces). - if (category is not (TypeCategory.Struct or TypeCategory.Class)) + if (category is not (TypeKind.Struct or TypeKind.Class)) { writer.WriteLine($"[ABI.{typeNs}.{nameStripped}ComWrappersMarshaller]"); } // [WindowsRuntimeClassName("Windows.Foundation.IReference`1<.>")] for non-class types. - if (category != TypeCategory.Class) + if (category != TypeKind.Class) { writer.WriteLine($"[WindowsRuntimeClassName(\"Windows.Foundation.IReference`1<{fullName}>\")]"); } diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index 38c9ada0e..bb361731a 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -7,6 +7,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -96,7 +97,7 @@ private static string GetAbiFieldType(ProjectionEmitContext context, TypeSignatu if (ft is TypeDefOrRefSignature tdr && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, tdr) is TypeDefinition fieldTd - && TypeCategorization.GetCategory(fieldTd) == TypeCategory.Struct + && TypeCategorization.GetCategory(fieldTd) == TypeKind.Struct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldTd)) { return TypedefNameWriter.WriteTypedefName(context, fieldTd, TypedefNameType.ABI, false).Format(); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 2d7d40315..73a6fd5da 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -10,6 +10,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -29,10 +30,10 @@ public static void AddMetadataTypeEntry(ProjectionEmitContext context, TypeDefin return; } - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); - if ((cat == TypeCategory.Class && TypeCategorization.IsStatic(type)) || - (cat == TypeCategory.Interface && TypeCategorization.IsExclusiveTo(type))) + if ((cat == TypeKind.Class && TypeCategorization.IsStatic(type)) || + (cat == TypeKind.Interface && TypeCategorization.IsExclusiveTo(type))) { return; } diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 5736993a8..23159ed60 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -12,6 +12,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -292,7 +293,7 @@ internal static void WriteComWrapperMarshallerAttributeBody(IndentedTextWriter w public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { // Skip exclusive interfaces and projection-internal interfaces. - if (TypeCategorization.GetCategory(type) == TypeCategory.Interface && + if (TypeCategorization.GetCategory(type) == TypeKind.Interface && (TypeCategorization.IsExclusiveTo(type) || TypeCategorization.IsProjectionInternal(type))) { return; @@ -338,9 +339,9 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe WriteTypeMapAttribute(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"\"{value}\"", $"typeof({target})", $"typeof({projectionName})"); // For non-interface, non-struct authored types, emit proxy association. - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); - if (cat is not (TypeCategory.Interface or TypeCategory.Struct) && context.Settings.Component) + if (cat is not (TypeKind.Interface or TypeKind.Struct) && context.Settings.Component) { WriteTypeMapAssociation(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"typeof({projectionName})", $"typeof({target})"); writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 768a277aa..8ef1080e4 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -7,6 +7,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -50,10 +51,10 @@ public static nint Vtable [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] """); - bool isBlittableStructType = blittable && TypeCategorization.GetCategory(type) == TypeCategory.Struct; - bool isNonBlittableStructType = !blittable && TypeCategorization.GetCategory(type) == TypeCategory.Struct; + bool isBlittableStructType = blittable && TypeCategorization.GetCategory(type) == TypeKind.Struct; + bool isNonBlittableStructType = !blittable && TypeCategorization.GetCategory(type) == TypeKind.Struct; - if ((blittable && TypeCategorization.GetCategory(type) != TypeCategory.Struct) + if ((blittable && TypeCategorization.GetCategory(type) != TypeKind.Struct) || isBlittableStructType) { // For blittable types and blittable structs: direct memcpy via C# struct assignment. @@ -108,7 +109,7 @@ public static int get_Value(void* thisPtr, void* result) } """); } - else if (TypeCategorization.GetCategory(type) is TypeCategory.Class or TypeCategory.Delegate) + else if (TypeCategorization.GetCategory(type) is TypeKind.Class or TypeKind.Delegate) { // Non-blittable runtime class / delegate: marshal via Marshaller and detach. WriteProjectedSignatureCallback projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index a0b0f69e7..71bda93fd 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -8,6 +8,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -40,20 +41,20 @@ private static IEnumerable GetInstanceFields(TypeDefinition typ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); // A struct field is "blittable" when its projected and ABI layouts match (no per-field // marshalling). Detect that via AbiTypeKindResolver.IsBlittableStruct: it returns true // for self-mapped structs with RequiresMarshaling=false and for user structs whose // fields are all blittable. TypeDefOrRefSignature sig = type.ToTypeSignature(false) is TypeDefOrRefSignature td2 ? td2 : null!; - bool blittableStruct = cat == TypeCategory.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); - bool isEnum = cat == TypeCategory.Enum; + bool blittableStruct = cat == TypeKind.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); + bool isEnum = cat == TypeKind.Enum; // Complex structs are the remaining (non-blittable, non-mapped) structs that need a // per-field marshaller class because at least one field is a reference type, generic // instance, or marshalling-mapped value. - bool isNonBlittableStruct = cat == TypeCategory.Struct && !blittableStruct; + bool isNonBlittableStruct = cat == TypeKind.Struct && !blittableStruct; // Detect Nullable reference fields to determine whether the struct's BoxToUnmanaged // call needs CreateComInterfaceFlags.TrackerSupport . @@ -132,7 +133,7 @@ public static unsafe class {{nameStripped}}Marshaller } else if (ft is TypeDefOrRefSignature ftd && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, ftd) is TypeDefinition fieldStructTd - && TypeCategorization.GetCategory(fieldStructTd) == TypeCategory.Struct + && TypeCategorization.GetCategory(fieldStructTd) == TypeKind.Struct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd)) { // Nested non-blittable struct: marshal via its Marshaller. @@ -193,7 +194,7 @@ public static unsafe class {{nameStripped}}Marshaller } else if (ft is TypeDefOrRefSignature ftd2 && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, ftd2) is TypeDefinition fieldStructTd2 - && TypeCategorization.GetCategory(fieldStructTd2) == TypeCategory.Struct + && TypeCategorization.GetCategory(fieldStructTd2) == TypeKind.Struct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd2)) { // Nested non-blittable struct: convert via its Marshaller. @@ -241,7 +242,7 @@ public static void Dispose({{abi}} value) } else if (ft is TypeDefOrRefSignature ftd3 && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, ftd3) is TypeDefinition fieldStructTd3 - && TypeCategorization.GetCategory(fieldStructTd3) == TypeCategory.Struct + && TypeCategorization.GetCategory(fieldStructTd3) == TypeKind.Struct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd3)) { // Nested non-blittable struct: dispose via its Marshaller. @@ -344,7 +345,7 @@ file static class {{nameStripped}}InterfaceEntriesImpl // is NOT emitted for STRUCTS (the attribute is supplied by cswinrtgen instead). Enums // and other types still emit it from write_abi_enum/etc. - if (context.Settings.Component && cat == TypeCategory.Struct) + if (context.Settings.Component && cat == TypeKind.Struct) { return; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs index 5f16cc230..ddee08bad 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs @@ -8,6 +8,7 @@ using AsmResolver.DotNet; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Generation; @@ -96,23 +97,23 @@ internal void WriteGeneratedInterfaceIidsFile() } iidWritten = true; - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); switch (cat) { - case TypeCategory.Delegate: + case TypeKind.Delegate: IidExpressionGenerator.WriteIidGuidPropertyFromSignature(guidIndented, guidContext, type); IidExpressionGenerator.WriteIidGuidPropertyFromType(guidIndented, guidContext, type); break; - case TypeCategory.Enum: + case TypeKind.Enum: IidExpressionGenerator.WriteIidGuidPropertyFromSignature(guidIndented, guidContext, type); break; - case TypeCategory.Interface: + case TypeKind.Interface: IidExpressionGenerator.WriteIidGuidPropertyFromType(guidIndented, guidContext, type); break; - case TypeCategory.Struct: + case TypeKind.Struct: IidExpressionGenerator.WriteIidGuidPropertyFromSignature(guidIndented, guidContext, type); break; - case TypeCategory.Class: + case TypeKind.Class: IidExpressionGenerator.WriteIidGuidPropertyForClassInterfaces(guidIndented, guidContext, type, interfacesFromClassesEmitted); break; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index 31917c283..e5d81cb14 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -9,6 +9,7 @@ using WindowsRuntime.ProjectionWriter.Factories; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Generation; @@ -59,10 +60,10 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); switch (cat) { - case TypeCategory.Class: + case TypeKind.Class: if (!TypeCategorization.IsStatic(type) && !TypeCategorization.IsAttributeType(type)) { if (_settings.Component) @@ -76,19 +77,19 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe } break; - case TypeCategory.Delegate: + case TypeKind.Delegate: MetadataAttributeFactory.WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(writer, context, type, true); MetadataAttributeFactory.WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(writer, context, type); break; - case TypeCategory.Enum: + case TypeKind.Enum: MetadataAttributeFactory.WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(writer, context, type, true); MetadataAttributeFactory.WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(writer, context, type); break; - case TypeCategory.Interface: + case TypeKind.Interface: MetadataAttributeFactory.WriteWinRTIdicTypeMapGroupAssemblyAttribute(writer, context, type); MetadataAttributeFactory.WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(writer, context, type); break; - case TypeCategory.Struct: + case TypeKind.Struct: if (!TypeCategorization.IsApiContractType(type)) { MetadataAttributeFactory.WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(writer, context, type, true); @@ -124,10 +125,10 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe } // Write the projected type per category - TypeCategory category = TypeCategorization.GetCategory(type); + TypeKind category = TypeCategorization.GetCategory(type); ProjectionFileBuilder.WriteType(writer, context, type, category); - if (category == TypeCategory.Class && !TypeCategorization.IsAttributeType(type)) + if (category == TypeKind.Class && !TypeCategorization.IsAttributeType(type)) { MetadataAttributeFactory.AddDefaultInterfaceEntry(context, type, defaultInterfaceEntries); MetadataAttributeFactory.AddExclusiveToInterfaceEntries(context, type, exclusiveToInterfaceEntries); @@ -138,11 +139,11 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe ComponentFactory.WriteFactoryClass(writer, context, type); } } - else if (category is TypeCategory.Delegate or TypeCategory.Enum or TypeCategory.Interface) + else if (category is TypeKind.Delegate or TypeKind.Enum or TypeKind.Interface) { ComponentFactory.AddMetadataTypeEntry(context, type, authoredTypeNameToMetadataMap); } - else if (category == TypeCategory.Struct && !TypeCategorization.IsApiContractType(type)) + else if (category == TypeKind.Struct && !TypeCategorization.IsApiContractType(type)) { ComponentFactory.AddMetadataTypeEntry(context, type, authoredTypeNameToMetadataMap); } @@ -174,7 +175,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - if (TypeCategorization.GetCategory(type) != TypeCategory.Class) + if (TypeCategorization.GetCategory(type) != TypeKind.Class) { continue; } @@ -225,7 +226,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - TypeCategory category = TypeCategorization.GetCategory(type); + TypeKind category = TypeCategorization.GetCategory(type); ProjectionFileBuilder.WriteAbiType(writer, context, type, category); } writer.WriteEndAbiNamespace(context); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index f45682626..b431f3616 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -179,7 +179,7 @@ public static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature sig) def = cache.Find(ns, name); } - if (def is not null && TypeCategorization.GetCategory(def) == TypeCategory.Enum) + if (def is not null && TypeCategorization.GetCategory(def) == TypeKind.Enum) { return cache is null ? "int" : GetProjectedEnumName(def); } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 9555f2a5a..12aa681cb 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -5,6 +5,7 @@ using AsmResolver.DotNet.Signatures; using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -15,14 +16,14 @@ internal static partial class AbiTypeHelpers /// public static bool IsTypeBlittable(MetadataCache cache, TypeDefinition type) { - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); - if (cat == TypeCategory.Enum) + if (cat == TypeKind.Enum) { return true; } - if (cat != TypeCategory.Struct) + if (cat != TypeKind.Struct) { return false; } @@ -153,14 +154,14 @@ internal static bool IsEnumType(MetadataCache cache, TypeSignature sig) if (td.Type is TypeDefinition def) { - return TypeCategorization.GetCategory(def) == TypeCategory.Enum; + return TypeCategorization.GetCategory(def) == TypeKind.Enum; } if (td.Type is TypeReference tr) { (string ns, string name) = tr.Names(); TypeDefinition? resolved = cache.Find(ns, name); - return resolved is not null && TypeCategorization.GetCategory(resolved) == TypeCategory.Enum; + return resolved is not null && TypeCategorization.GetCategory(resolved) == TypeKind.Enum; } return false; @@ -176,8 +177,8 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur // Same-module: use the resolved category directly. if (td.Type is TypeDefinition def) { - TypeCategory cat = TypeCategorization.GetCategory(def); - return cat is TypeCategory.Class or TypeCategory.Interface or TypeCategory.Delegate; + TypeKind cat = TypeCategorization.GetCategory(def); + return cat is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } // Cross-module typeref: try to resolve via the metadata cache to check category @@ -189,8 +190,8 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur if (resolved is not null) { - TypeCategory cat = TypeCategorization.GetCategory(resolved); - return cat is TypeCategory.Class or TypeCategory.Interface or TypeCategory.Delegate; + TypeKind cat = TypeCategorization.GetCategory(resolved); + return cat is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } } @@ -231,7 +232,7 @@ ElementType.R8 or // Enum (TypeDefOrRef-based value type with non-Object base) - same module or cross-module if (sig is TypeDefOrRefSignature td) { - if (td.Type is TypeDefinition def && TypeCategorization.GetCategory(def) == TypeCategory.Enum) + if (td.Type is TypeDefinition def && TypeCategorization.GetCategory(def) == TypeKind.Enum) { return true; } @@ -242,7 +243,7 @@ ElementType.R8 or (string ns, string name) = tr.Names(); TypeDefinition? resolved = cache.Find(ns, name); - if (resolved is not null && TypeCategorization.GetCategory(resolved) == TypeCategory.Enum) + if (resolved is not null && TypeCategorization.GetCategory(resolved) == TypeKind.Enum) { return true; } @@ -290,7 +291,7 @@ internal static bool IsNonBlittableStruct(MetadataCache cache, TypeSignature sig return false; } - if (TypeCategorization.GetCategory(def) != TypeCategory.Struct) + if (TypeCategorization.GetCategory(def) != TypeKind.Struct) { return false; } @@ -382,7 +383,7 @@ internal static bool IsBlittableStruct(MetadataCache cache, TypeSignature sig) // Mapped struct types short-circuit based on the mapping's RequiresMarshaling flag // (only applies to actual structs, not mapped interfaces like IAsyncAction). - if (TypeCategorization.GetCategory(def) == TypeCategory.Struct) + if (TypeCategorization.GetCategory(def) == TypeKind.Struct) { (string sNs, string sName) = td.Type.Names(); @@ -393,7 +394,7 @@ internal static bool IsBlittableStruct(MetadataCache cache, TypeSignature sig) } // If the type isn't a struct type, then by definition it isn't blittable - if (TypeCategorization.GetCategory(def) != TypeCategory.Struct) + if (TypeCategorization.GetCategory(def) != TypeKind.Struct) { return false; } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index f9a00473b..6bafb86d9 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -6,6 +6,7 @@ using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.References; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; @@ -39,13 +40,13 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext writer.Write("global::WindowsRuntime.InteropServices.WindowsRuntimeTypeName"); break; case TypeSemantics.Definition d: - if (TypeCategorization.GetCategory(d.Type) is TypeCategory.Enum) + if (TypeCategorization.GetCategory(d.Type) is TypeKind.Enum) { // Enums in WinRT ABI use the projected enum type directly (since their C# // layout matches their underlying integer ABI representation 1:1). TypedefNameWriter.WriteTypedefName(writer, context, d.Type, TypedefNameType.Projected, true); } - else if (TypeCategorization.GetCategory(d.Type) is TypeCategory.Struct) + else if (TypeCategorization.GetCategory(d.Type) is TypeKind.Struct) { (string dNs, string dName) = d.Type.Names(); @@ -139,16 +140,16 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext if (rd is not null) { - TypeCategory cat = TypeCategorization.GetCategory(rd); + TypeKind cat = TypeCategorization.GetCategory(rd); - if (cat == TypeCategory.Enum) + if (cat == TypeKind.Enum) { // Enums use the projected enum type directly (C# layout == ABI layout). TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); break; } - if (cat == TypeCategory.Struct) + if (cat == TypeKind.Struct) { // Special case: HResult is mapped to System.Exception (a reference type) // but its ABI representation is the global::ABI.System.Exception struct diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs index 8cdbf9dd8..7d4ecdcf3 100644 --- a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -5,6 +5,7 @@ using WindowsRuntime.ProjectionWriter.Errors; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -164,10 +165,10 @@ private static void WriteSignature(IndentedTextWriter writer, ProjectionEmitCont /// The type to emit a signature for. private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - TypeCategory cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeCategorization.GetCategory(type); switch (cat) { - case TypeCategory.Enum: + case TypeKind.Enum: writer.Write("enum("); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); TypedefNameWriter.WriteTypeParams(writer, type); @@ -175,7 +176,7 @@ private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionE writer.Write(TypeCategorization.IsFlagsEnum(type) ? "u4" : "i4"); writer.Write(")"); break; - case TypeCategory.Struct: + case TypeKind.Struct: writer.Write("struct("); TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); TypedefNameWriter.WriteTypeParams(writer, type); @@ -200,17 +201,17 @@ private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionE } writer.Write(")"); break; - case TypeCategory.Delegate: + case TypeKind.Delegate: writer.Write("delegate({"); IidExpressionGenerator.WriteGuid(writer, type, true); writer.Write("})"); break; - case TypeCategory.Interface: + case TypeKind.Interface: writer.Write("{"); IidExpressionGenerator.WriteGuid(writer, type, true); writer.Write("}"); break; - case TypeCategory.Class: + case TypeKind.Class: ITypeDefOrRef? defaultIface = type.GetDefaultInterface(); if (defaultIface is TypeDefinition di) diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 209032256..53ab75bb1 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -7,6 +7,7 @@ using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; +using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -78,7 +79,7 @@ public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitCon // Authored interfaces that aren't exclusive use the same authored interface. if (authoredType && nameToWrite == TypedefNameType.CCW && - TypeCategorization.GetCategory(type) == TypeCategory.Interface && + TypeCategorization.GetCategory(type) == TypeKind.Interface && !TypeCategorization.IsExclusiveTo(type)) { nameToWrite = TypedefNameType.Projected; diff --git a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs index 3311ebb79..9c46a17db 100644 --- a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs +++ b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Models; namespace WindowsRuntime.ProjectionWriter.Metadata; @@ -46,13 +47,13 @@ internal sealed class NamespaceMembers(string name) public void AddType(TypeDefinition type) { Types.Add(type); - TypeCategory category = TypeCategorization.GetCategory(type); + TypeKind category = TypeCategorization.GetCategory(type); switch (category) { - case TypeCategory.Interface: + case TypeKind.Interface: Interfaces.Add(type); break; - case TypeCategory.Class: + case TypeKind.Class: if (TypeCategorization.IsAttributeType(type)) { Attributes.Add(type); @@ -63,10 +64,10 @@ public void AddType(TypeDefinition type) } break; - case TypeCategory.Enum: + case TypeKind.Enum: Enums.Add(type); break; - case TypeCategory.Struct: + case TypeKind.Struct: if (TypeCategorization.IsApiContractType(type)) { Contracts.Add(type); @@ -77,7 +78,7 @@ public void AddType(TypeDefinition type) } break; - case TypeCategory.Delegate: + case TypeKind.Delegate: Delegates.Add(type); break; } diff --git a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs index 96b00e362..de3f93d7c 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs @@ -2,23 +2,12 @@ // Licensed under the MIT License. using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Models; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter.Metadata; -/// -/// Categorization of a Windows Runtime type definition. -/// -internal enum TypeCategory -{ - Interface, - Class, - Enum, - Struct, - Delegate, -} - /// /// Static type categorization helpers, mirroring winmd::reader::get_category and various /// @@ -27,15 +16,15 @@ internal static class TypeCategorization /// /// Determines a type's category (class/interface/enum/struct/delegate). /// - public static TypeCategory GetCategory(TypeDefinition type) + public static TypeKind GetCategory(TypeDefinition type) { return type switch { - { IsInterface: true } => TypeCategory.Interface, - { IsEnum: true } => TypeCategory.Enum, - { IsValueType: true } => TypeCategory.Struct, - { IsDelegate: true } => TypeCategory.Delegate, - _ => TypeCategory.Class + { IsInterface: true } => TypeKind.Interface, + { IsEnum: true } => TypeKind.Enum, + { IsValueType: true } => TypeKind.Struct, + { IsDelegate: true } => TypeKind.Delegate, + _ => TypeKind.Class }; } @@ -44,7 +33,7 @@ public static TypeCategory GetCategory(TypeDefinition type) /// public static bool IsAttributeType(TypeDefinition type) { - if (GetCategory(type) != TypeCategory.Class) + if (GetCategory(type) != TypeKind.Class) { return false; } @@ -70,7 +59,7 @@ public static bool IsAttributeType(TypeDefinition type) /// public static bool IsApiContractType(TypeDefinition type) { - return GetCategory(type) == TypeCategory.Struct && + return GetCategory(type) == TypeKind.Struct && type.HasAttribute(WindowsFoundationMetadata, "ApiContractAttribute"); } @@ -79,7 +68,7 @@ public static bool IsApiContractType(TypeDefinition type) /// public static bool IsStatic(TypeDefinition type) { - return GetCategory(type) == TypeCategory.Class && type.IsAbstract && type.IsSealed; + return GetCategory(type) == TypeKind.Class && type.IsAbstract && type.IsSealed; } /// @@ -87,7 +76,7 @@ public static bool IsStatic(TypeDefinition type) /// public static bool IsExclusiveTo(TypeDefinition type) { - return GetCategory(type) == TypeCategory.Interface && + return GetCategory(type) == TypeKind.Interface && type.HasAttribute(WindowsFoundationMetadata, ExclusiveToAttribute); } @@ -96,7 +85,7 @@ public static bool IsExclusiveTo(TypeDefinition type) /// public static bool IsFlagsEnum(TypeDefinition type) { - return GetCategory(type) == TypeCategory.Enum && + return GetCategory(type) == TypeKind.Enum && type.HasAttribute("System", "FlagsAttribute"); } diff --git a/src/WinRT.Projection.Writer/Models/TypeKind.cs b/src/WinRT.Projection.Writer/Models/TypeKind.cs new file mode 100644 index 000000000..c20ecb5ab --- /dev/null +++ b/src/WinRT.Projection.Writer/Models/TypeKind.cs @@ -0,0 +1,16 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace WindowsRuntime.ProjectionWriter.Models; + +/// +/// Categorization of a Windows Runtime type definition. +/// +internal enum TypeKind +{ + Interface, + Class, + Enum, + Struct, + Delegate, +} diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index cbdd37276..680bc9af6 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -99,7 +99,7 @@ public AbiTypeKind Resolve(TypeSignature signature) { if (signature is TypeDefOrRefSignature td && td.Type is TypeDefinition def && - TypeCategorization.GetCategory(def) == TypeCategory.Delegate) + TypeCategorization.GetCategory(def) == TypeKind.Delegate) { return AbiTypeKind.Delegate; } From 249de76d46cf13ba8d7315bacae05522a9c62d3c Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 11:18:19 -0700 Subject: [PATCH 166/171] Add TypeDefinition classifier extension properties and migrate direct-comparison callers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add five fundamental type-classifier extension properties on AsmResolver's TypeDefinition (TypeDefinitionExtensions.cs): - IsStruct: value type that isn't an enum - IsAttributeType: class whose immediate base is System.Attribute (XML calls out the 'immediate base only' restriction; matches the original loop semantics exactly) - IsStatic: class that is both abstract and sealed - IsFlagsEnum: enum carrying [System.FlagsAttribute] - IsGeneric: type has any generic type parameters Migrate all direct-comparison call sites: - TypeCategorization.GetCategory(t) == TypeKind.Interface/Enum/Struct/Delegate → t.IsInterface / t.IsEnum / t.IsStruct / t.IsDelegate - TypeCategorization.GetCategory(t) != TypeKind.X / 'is TypeKind.X' / 'is not TypeKind.X' → same with negation - TypeCategorization.IsAttributeType(t) / IsStatic(t) / IsFlagsEnum(t) / IsGeneric(t) → t.IsAttributeType / t.IsStatic / t.IsFlagsEnum / t.IsGeneric Remove the four corresponding static helpers from Metadata/TypeCategorization.cs; simplify the three remaining WinRT-specific helpers (IsApiContractType, IsExclusiveTo, IsProjectionInternal) to use the new properties internally instead of calling GetCategory. Comparisons against TypeKind.Class (and multi-kind 'is TypeKind.X or TypeKind.Y' patterns) are intentionally left untouched - they will be migrated in the next commit when the new TypeKindResolver is introduced. Pruned the 'using WindowsRuntime.ProjectionWriter.Models;' from the two files that no longer reference TypeKind after this migration (AbiStructFactory, TypedefNameWriter). Build clean (0 warnings); validation harness reports 0 diffs across all 3 regen scenarios (pushnot, everything-with-ui, windows). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 8 +-- .../Extensions/TypeDefinitionExtensions.cs | 61 +++++++++++++++++++ .../Factories/AbiClassFactory.cs | 2 +- .../Factories/AbiStructFactory.cs | 3 +- .../Factories/ClassFactory.cs | 4 +- .../Factories/ComponentFactory.cs | 4 +- .../Factories/MetadataAttributeFactory.cs | 2 +- .../Factories/ReferenceImplFactory.cs | 6 +- .../Factories/StructEnumMarshallerFactory.cs | 6 +- .../ProjectionGenerator.GeneratedIids.cs | 2 +- .../ProjectionGenerator.Namespace.cs | 12 ++-- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 +- .../Helpers/AbiTypeHelpers.Blittability.cs | 14 ++--- .../Helpers/AbiTypeWriter.cs | 4 +- .../Helpers/SignatureGenerator.cs | 2 +- .../Helpers/TypedefNameWriter.cs | 3 +- .../Metadata/NamespaceMembers.cs | 2 +- .../Metadata/TypeCategorization.cs | 58 +----------------- .../Resolvers/AbiTypeKindResolver.cs | 2 +- 19 files changed, 102 insertions(+), 95 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 72827b51f..c19e4fe33 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -27,7 +27,7 @@ public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext co { switch (category) { - case TypeKind.Class when TypeCategorization.IsAttributeType(type): + case TypeKind.Class when type.IsAttributeType: WriteAttribute(writer, context, type); break; case TypeKind.Class: @@ -91,7 +91,7 @@ private static void WriteEnum(IndentedTextWriter writer, ProjectionEmitContext c return; } - bool isFlags = TypeCategorization.IsFlagsEnum(type); + bool isFlags = type.IsFlagsEnum; string enumUnderlyingType = isFlags ? "uint" : "int"; string typeName = type.GetRawName(); @@ -162,11 +162,11 @@ private static void WriteStruct(IndentedTextWriter writer, ProjectionEmitContext if (semantics is TypeSemantics.Definition d) { - isInterface = TypeCategorization.GetCategory(d.Type) == TypeKind.Interface; + isInterface = d.Type.IsInterface; } else if (semantics is TypeSemantics.GenericInstance gi) { - isInterface = TypeCategorization.GetCategory(gi.GenericType) == TypeKind.Interface; + isInterface = gi.GenericType.IsInterface; } fields.Add((fieldType, fieldName, paramName, isInterface)); diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 1853334f2..a99345957 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -18,6 +18,67 @@ internal static class TypeDefinitionExtensions { extension(TypeDefinition type) { + /// + /// Returns whether the type is a struct (a value type that isn't an enum). + /// + public bool IsStruct => type.IsValueType && !type.IsEnum; + + /// + /// Returns whether the type is a class whose immediate base is . + /// + /// + /// This check only inspects the type's immediate base. Types that inherit + /// through an intermediate base class are reported as + /// . WinMD attribute types always extend + /// directly, so this matches their shape exactly. + /// + public bool IsAttributeType + { + get + { + if (type.IsInterface || type.IsValueType || type.IsDelegate) + { + return false; + } + + if (type.BaseType is not { } baseType) + { + return false; + } + + (string ns, string name) = baseType.Names(); + + return ns == "System" && name == "Attribute"; + } + } + + /// + /// Returns whether the type is a static class (i.e. a class that is both + /// abstract and sealed). + /// + public bool IsStatic + { + get + { + if (type.IsInterface || type.IsValueType || type.IsDelegate) + { + return false; + } + + return type.IsAbstract && type.IsSealed; + } + } + + /// + /// Returns whether the type is an enum marked with [System.FlagsAttribute]. + /// + public bool IsFlagsEnum => type.IsEnum && type.HasAttribute("System", "FlagsAttribute"); + + /// + /// Returns whether the type has any generic type parameters (i.e. is a generic type definition). + /// + public bool IsGeneric => type.GenericParameters.Count > 0; + /// /// Returns the type's methods filtered to exclude special-name methods (property accessors, /// event accessors, and runtime-special methods like .ctor). diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index d1fb12450..f1051ac0f 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -23,7 +23,7 @@ internal static class AbiClassFactory public static void WriteAbiClass(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { // Static classes don't get a *Marshaller (no instances). - if (TypeCategorization.IsStatic(type)) + if (type.IsStatic) { return; } diff --git a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs index bb361731a..076d6d820 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiStructFactory.cs @@ -7,7 +7,6 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; -using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -97,7 +96,7 @@ private static string GetAbiFieldType(ProjectionEmitContext context, TypeSignatu if (ft is TypeDefOrRefSignature tdr && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, tdr) is TypeDefinition fieldTd - && TypeCategorization.GetCategory(fieldTd) == TypeKind.Struct + && fieldTd.IsStruct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldTd)) { return TypedefNameWriter.WriteTypedefName(context, fieldTd, TypedefNameType.ABI, false).Format(); diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index e3c634d29..79e6cb695 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -493,7 +493,7 @@ public static void WriteClass(IndentedTextWriter writer, ProjectionEmitContext c return; } - if (TypeCategorization.IsStatic(type)) + if (type.IsStatic) { WriteStaticClass(writer, context, type); return; @@ -518,7 +518,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont WriteComWrapperMarshallerAttributeCallback comWrappersAttr = MetadataAttributeFactory.WriteComWrapperMarshallerAttribute(context, type); // are emitted as plain (non-partial) classes. - string modifiers = TypeCategorization.IsStatic(type) ? "static " : type.IsSealed ? "sealed " : ""; + string modifiers = type.IsStatic ? "static " : type.IsSealed ? "sealed " : ""; WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.Projected, false); WriteTypeInheritanceCallback inheritance = InterfaceFactory.WriteTypeInheritance(context, type, false, true); writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 73a6fd5da..bfbc2ca18 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -32,7 +32,7 @@ public static void AddMetadataTypeEntry(ProjectionEmitContext context, TypeDefin TypeKind cat = TypeCategorization.GetCategory(type); - if ((cat == TypeKind.Class && TypeCategorization.IsStatic(type)) || + if ((cat == TypeKind.Class && type.IsStatic) || (cat == TypeKind.Interface && TypeCategorization.IsExclusiveTo(type))) { return; @@ -53,7 +53,7 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo (string typeNs, string typeName) = type.Names(); string projectedTypeName = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, typeName); string factoryTypeName = $"{IdentifierEscaping.StripBackticks(typeName)}ServerActivationFactory"; - bool isActivatable = !TypeCategorization.IsStatic(type) && type.HasDefaultConstructor(); + bool isActivatable = !type.IsStatic && type.HasDefaultConstructor(); // Build the inheritance list: factory interfaces ([Activatable]/[Static]) only. MetadataCache cache = context.Cache; diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 23159ed60..a4a6eaff5 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -293,7 +293,7 @@ internal static void WriteComWrapperMarshallerAttributeBody(IndentedTextWriter w public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { // Skip exclusive interfaces and projection-internal interfaces. - if (TypeCategorization.GetCategory(type) == TypeKind.Interface && + if (type.IsInterface && (TypeCategorization.IsExclusiveTo(type) || TypeCategorization.IsProjectionInternal(type))) { return; diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 8ef1080e4..90b3a6b63 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -51,10 +51,10 @@ public static nint Vtable [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])] """); - bool isBlittableStructType = blittable && TypeCategorization.GetCategory(type) == TypeKind.Struct; - bool isNonBlittableStructType = !blittable && TypeCategorization.GetCategory(type) == TypeKind.Struct; + bool isBlittableStructType = blittable && type.IsStruct; + bool isNonBlittableStructType = !blittable && type.IsStruct; - if ((blittable && TypeCategorization.GetCategory(type) != TypeKind.Struct) + if ((blittable && !type.IsStruct) || isBlittableStructType) { // For blittable types and blittable structs: direct memcpy via C# struct assignment. diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 71bda93fd..fcfcdf297 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -133,7 +133,7 @@ public static unsafe class {{nameStripped}}Marshaller } else if (ft is TypeDefOrRefSignature ftd && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, ftd) is TypeDefinition fieldStructTd - && TypeCategorization.GetCategory(fieldStructTd) == TypeKind.Struct + && fieldStructTd.IsStruct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd)) { // Nested non-blittable struct: marshal via its Marshaller. @@ -194,7 +194,7 @@ public static unsafe class {{nameStripped}}Marshaller } else if (ft is TypeDefOrRefSignature ftd2 && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, ftd2) is TypeDefinition fieldStructTd2 - && TypeCategorization.GetCategory(fieldStructTd2) == TypeKind.Struct + && fieldStructTd2.IsStruct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd2)) { // Nested non-blittable struct: convert via its Marshaller. @@ -242,7 +242,7 @@ public static void Dispose({{abi}} value) } else if (ft is TypeDefOrRefSignature ftd3 && AbiTypeHelpers.TryResolveStructTypeDef(context.Cache, ftd3) is TypeDefinition fieldStructTd3 - && TypeCategorization.GetCategory(fieldStructTd3) == TypeKind.Struct + && fieldStructTd3.IsStruct && !AbiTypeHelpers.IsTypeBlittable(context.Cache, fieldStructTd3)) { // Nested non-blittable struct: dispose via its Marshaller. diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs index ddee08bad..605592d9a 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs @@ -83,7 +83,7 @@ internal void WriteGeneratedInterfaceIidsFile() continue; } - if (TypeCategorization.IsGeneric(type)) + if (type.IsGeneric) { continue; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index e5d81cb14..a8ee6844b 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -47,7 +47,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - if (TypeCategorization.IsGeneric(type)) + if (type.IsGeneric) { continue; } @@ -64,7 +64,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe switch (cat) { case TypeKind.Class: - if (!TypeCategorization.IsStatic(type) && !TypeCategorization.IsAttributeType(type)) + if (!type.IsStatic && !type.IsAttributeType) { if (_settings.Component) { @@ -118,7 +118,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe (string ns2, string nm2) = type.Names(); // Skip generic types and mapped types - if (MappedTypes.Get(ns2, nm2) is not null || TypeCategorization.IsGeneric(type)) + if (MappedTypes.Get(ns2, nm2) is not null || type.IsGeneric) { written = true; continue; @@ -128,7 +128,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe TypeKind category = TypeCategorization.GetCategory(type); ProjectionFileBuilder.WriteType(writer, context, type, category); - if (category == TypeKind.Class && !TypeCategorization.IsAttributeType(type)) + if (category == TypeKind.Class && !type.IsAttributeType) { MetadataAttributeFactory.AddDefaultInterfaceEntry(context, type, defaultInterfaceEntries); MetadataAttributeFactory.AddExclusiveToInterfaceEntries(context, type, exclusiveToInterfaceEntries); @@ -203,7 +203,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - if (TypeCategorization.IsGeneric(type)) + if (type.IsGeneric) { continue; } @@ -221,7 +221,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - if (TypeCategorization.IsAttributeType(type)) + if (type.IsAttributeType) { continue; } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index b431f3616..32500f5e2 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -179,7 +179,7 @@ public static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature sig) def = cache.Find(ns, name); } - if (def is not null && TypeCategorization.GetCategory(def) == TypeKind.Enum) + if (def is not null && def.IsEnum) { return cache is null ? "int" : GetProjectedEnumName(def); } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 12aa681cb..2b339bb4b 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -154,14 +154,14 @@ internal static bool IsEnumType(MetadataCache cache, TypeSignature sig) if (td.Type is TypeDefinition def) { - return TypeCategorization.GetCategory(def) == TypeKind.Enum; + return def.IsEnum; } if (td.Type is TypeReference tr) { (string ns, string name) = tr.Names(); TypeDefinition? resolved = cache.Find(ns, name); - return resolved is not null && TypeCategorization.GetCategory(resolved) == TypeKind.Enum; + return resolved is not null && resolved.IsEnum; } return false; @@ -232,7 +232,7 @@ ElementType.R8 or // Enum (TypeDefOrRef-based value type with non-Object base) - same module or cross-module if (sig is TypeDefOrRefSignature td) { - if (td.Type is TypeDefinition def && TypeCategorization.GetCategory(def) == TypeKind.Enum) + if (td.Type is TypeDefinition def && def.IsEnum) { return true; } @@ -243,7 +243,7 @@ ElementType.R8 or (string ns, string name) = tr.Names(); TypeDefinition? resolved = cache.Find(ns, name); - if (resolved is not null && TypeCategorization.GetCategory(resolved) == TypeKind.Enum) + if (resolved is not null && resolved.IsEnum) { return true; } @@ -291,7 +291,7 @@ internal static bool IsNonBlittableStruct(MetadataCache cache, TypeSignature sig return false; } - if (TypeCategorization.GetCategory(def) != TypeKind.Struct) + if (!def.IsStruct) { return false; } @@ -383,7 +383,7 @@ internal static bool IsBlittableStruct(MetadataCache cache, TypeSignature sig) // Mapped struct types short-circuit based on the mapping's RequiresMarshaling flag // (only applies to actual structs, not mapped interfaces like IAsyncAction). - if (TypeCategorization.GetCategory(def) == TypeKind.Struct) + if (def.IsStruct) { (string sNs, string sName) = td.Type.Names(); @@ -394,7 +394,7 @@ internal static bool IsBlittableStruct(MetadataCache cache, TypeSignature sig) } // If the type isn't a struct type, then by definition it isn't blittable - if (TypeCategorization.GetCategory(def) != TypeKind.Struct) + if (!def.IsStruct) { return false; } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 6bafb86d9..7654b4b6a 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -40,13 +40,13 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext writer.Write("global::WindowsRuntime.InteropServices.WindowsRuntimeTypeName"); break; case TypeSemantics.Definition d: - if (TypeCategorization.GetCategory(d.Type) is TypeKind.Enum) + if (d.Type.IsEnum) { // Enums in WinRT ABI use the projected enum type directly (since their C# // layout matches their underlying integer ABI representation 1:1). TypedefNameWriter.WriteTypedefName(writer, context, d.Type, TypedefNameType.Projected, true); } - else if (TypeCategorization.GetCategory(d.Type) is TypeKind.Struct) + else if (d.Type.IsStruct) { (string dNs, string dName) = d.Type.Names(); diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs index 7d4ecdcf3..d706d0c7d 100644 --- a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -173,7 +173,7 @@ private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionE TypedefNameWriter.WriteTypedefName(writer, context, type, TypedefNameType.NonProjected, true); TypedefNameWriter.WriteTypeParams(writer, type); writer.Write(";"); - writer.Write(TypeCategorization.IsFlagsEnum(type) ? "u4" : "i4"); + writer.Write(type.IsFlagsEnum ? "u4" : "i4"); writer.Write(")"); break; case TypeKind.Struct: diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index 53ab75bb1..cb0d544cd 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -7,7 +7,6 @@ using WindowsRuntime.ProjectionWriter.Factories.Callbacks; using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; -using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -79,7 +78,7 @@ public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitCon // Authored interfaces that aren't exclusive use the same authored interface. if (authoredType && nameToWrite == TypedefNameType.CCW && - TypeCategorization.GetCategory(type) == TypeKind.Interface && + type.IsInterface && !TypeCategorization.IsExclusiveTo(type)) { nameToWrite = TypedefNameType.Projected; diff --git a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs index 9c46a17db..3c5cc3e1f 100644 --- a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs +++ b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs @@ -54,7 +54,7 @@ public void AddType(TypeDefinition type) Interfaces.Add(type); break; case TypeKind.Class: - if (TypeCategorization.IsAttributeType(type)) + if (type.IsAttributeType) { Attributes.Add(type); } diff --git a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs index de3f93d7c..fdd1b27ac 100644 --- a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs +++ b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs @@ -28,47 +28,12 @@ public static TypeKind GetCategory(TypeDefinition type) }; } - /// - /// True if this is an Attribute-derived class. - /// - public static bool IsAttributeType(TypeDefinition type) - { - if (GetCategory(type) != TypeKind.Class) - { - return false; - } - - // Check immediate base type for System.Attribute (winmd attribute types extend it directly). - ITypeDefOrRef? cur = type.BaseType; - while (cur is not null) - { - if (cur.Namespace == "System" && cur.Name == "Attribute") - { - return true; - } - - // For attributes, the base type chain is short and we typically stop at a TypeRef - // pointing to System.Attribute. We don't try to resolve further. - return false; - } - return false; - } - /// /// True if this is an API contract struct type. /// public static bool IsApiContractType(TypeDefinition type) { - return GetCategory(type) == TypeKind.Struct && - type.HasAttribute(WindowsFoundationMetadata, "ApiContractAttribute"); - } - - /// - /// True if this type is a static class (abstract+sealed). - /// - public static bool IsStatic(TypeDefinition type) - { - return GetCategory(type) == TypeKind.Class && type.IsAbstract && type.IsSealed; + return type.IsStruct && type.HasAttribute(WindowsFoundationMetadata, "ApiContractAttribute"); } /// @@ -76,25 +41,7 @@ public static bool IsStatic(TypeDefinition type) /// public static bool IsExclusiveTo(TypeDefinition type) { - return GetCategory(type) == TypeKind.Interface && - type.HasAttribute(WindowsFoundationMetadata, ExclusiveToAttribute); - } - - /// - /// True if this is a [Flags] enum. - /// - public static bool IsFlagsEnum(TypeDefinition type) - { - return GetCategory(type) == TypeKind.Enum && - type.HasAttribute("System", "FlagsAttribute"); - } - - /// - /// True if this is a generic type (has type parameters). - /// - public static bool IsGeneric(TypeDefinition type) - { - return type.GenericParameters.Count > 0; + return type.IsInterface && type.HasAttribute(WindowsFoundationMetadata, ExclusiveToAttribute); } /// @@ -105,3 +52,4 @@ public static bool IsProjectionInternal(TypeDefinition type) return type.HasAttribute(WindowsRuntimeInternal, "ProjectionInternalAttribute"); } } + diff --git a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs index 680bc9af6..b83fe5368 100644 --- a/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs +++ b/src/WinRT.Projection.Writer/Resolvers/AbiTypeKindResolver.cs @@ -99,7 +99,7 @@ public AbiTypeKind Resolve(TypeSignature signature) { if (signature is TypeDefOrRefSignature td && td.Type is TypeDefinition def && - TypeCategorization.GetCategory(def) == TypeKind.Delegate) + def.IsDelegate) { return AbiTypeKind.Delegate; } From d2a2a82ec9cff3c996267267c4bbc102e05f477f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 11:21:59 -0700 Subject: [PATCH 167/171] Introduce TypeKindResolver, move WinRT helpers to TypeDefinitionExtensions, delete TypeCategorization.cs Final cleanup of the Metadata/TypeCategorization static class. Three concerns: 1. Introduce Resolvers/TypeKindResolver.cs - a small static class mirroring AbiTypeKindResolver's shape, with a single 'public static TypeKind Resolve(TypeDefinition type)' method that replaces TypeCategorization.GetCategory. Migrate all remaining GetCategory callers (mostly local-variable stores feeding switch statements + the multi-kind 'is TypeKind.Class or TypeKind.Delegate' patterns) to TypeKindResolver.Resolve. 2. Move the three remaining WinRT-specific helpers from TypeCategorization to TypeDefinitionExtensions as extension properties: - IsApiContractType: struct + [Windows.Foundation.Metadata.ApiContractAttribute] - IsExclusiveTo: interface + [Windows.Foundation.Metadata.ExclusiveToAttribute] - IsProjectionInternal: type marked [WindowsRuntime.Internal.ProjectionInternalAttribute] These live alongside the other WinRT-specific TypeDefinition extensions already in the file (GetVersion, GetContractVersion, TryGetWindowsRuntimeGuid, ...). 3. Delete Metadata/TypeCategorization.cs - all of its content has now been redistributed. Tidied up the using directives in AbiStructFactory.cs (added 'Metadata' for TypedefNameType, which was previously coming in transitively through 'using Metadata' for TypeCategorization) and AbiTypeHelpers.AbiTypeNames.cs (kept 'Metadata' for MetadataCache). Build clean (0 warnings); 'dotnet publish -r win-x64' for WinRT.Projection.Generator completes Native AOT codegen with no warnings; validation harness reports 0 diffs across all 3 regen scenarios (pushnot, everything-with-ui, windows). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Builders/ProjectionFileBuilder.cs | 2 +- .../Extensions/TypeDefinitionExtensions.cs | 21 +++++++ .../Factories/AbiClassFactory.cs | 7 ++- .../Factories/AbiInterfaceFactory.cs | 12 ++-- .../Factories/AbiInterfaceIDicFactory.cs | 2 +- .../Factories/ClassFactory.cs | 2 +- ...assMembersFactory.WriteInterfaceMembers.cs | 2 +- .../Factories/ClassMembersFactory.cs | 2 +- .../Factories/ComponentFactory.cs | 5 +- .../Factories/InterfaceFactory.cs | 14 ++--- .../Factories/MetadataAttributeFactory.cs | 11 ++-- .../Factories/ReferenceImplFactory.cs | 5 +- .../Factories/StructEnumMarshallerFactory.cs | 3 +- .../ProjectionGenerator.GeneratedIids.cs | 3 +- .../ProjectionGenerator.Namespace.cs | 15 ++--- .../Helpers/AbiTypeHelpers.Blittability.cs | 7 ++- .../Helpers/AbiTypeWriter.cs | 3 +- .../Helpers/ObjRefNameGenerator.cs | 4 +- .../Helpers/SignatureGenerator.cs | 3 +- .../Helpers/TypedefNameWriter.cs | 4 +- .../Metadata/NamespaceMembers.cs | 5 +- .../Metadata/TypeCategorization.cs | 55 ------------------- .../Resolvers/TypeKindResolver.cs | 31 +++++++++++ 23 files changed, 113 insertions(+), 105 deletions(-) delete mode 100644 src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs create mode 100644 src/WinRT.Projection.Writer/Resolvers/TypeKindResolver.cs diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index c19e4fe33..563e3ac38 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -42,7 +42,7 @@ public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext co case TypeKind.Interface: InterfaceFactory.WriteInterface(writer, context, type); break; - case TypeKind.Struct when TypeCategorization.IsApiContractType(type): + case TypeKind.Struct when type.IsApiContractType: WriteContract(writer, context, type); break; case TypeKind.Struct: diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index a99345957..4b3eb89d6 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -8,6 +8,7 @@ using AsmResolver.DotNet.Signatures; using WindowsRuntime.ProjectionWriter.Metadata; using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; +using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; namespace WindowsRuntime.ProjectionWriter; @@ -79,6 +80,26 @@ public bool IsStatic /// public bool IsGeneric => type.GenericParameters.Count > 0; + /// + /// Returns whether the type is a struct marked with + /// [Windows.Foundation.Metadata.ApiContractAttribute] (i.e. a WinRT API contract). + /// + public bool IsApiContractType => type.IsStruct && type.HasWindowsFoundationMetadataAttribute("ApiContractAttribute"); + + /// + /// Returns whether the type is an interface marked with + /// [Windows.Foundation.Metadata.ExclusiveToAttribute] (i.e. an interface + /// declared "exclusive to" a single runtime class). + /// + public bool IsExclusiveTo => type.IsInterface && type.HasWindowsFoundationMetadataAttribute(ExclusiveToAttribute); + + /// + /// Returns whether the type is marked with + /// [WindowsRuntime.Internal.ProjectionInternalAttribute] (i.e. a type that + /// should be projected as internal rather than public). + /// + public bool IsProjectionInternal => type.HasAttribute(WindowsRuntimeInternal, "ProjectionInternalAttribute"); + /// /// Returns the type's methods filtered to exclude special-name methods (property accessors, /// event accessors, and runtime-special methods like .ctor). diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index f1051ac0f..4be813f62 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -7,6 +7,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -119,7 +120,7 @@ internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, Proje string typeNs = type.GetRawNamespace(); string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; - TypeKind category = TypeCategorization.GetCategory(type); + TypeKind category = TypeKindResolver.Resolve(type); // [WindowsRuntimeReferenceType(typeof(?))] for non-delegate, non-class types // (i.e. enums, structs, interfaces). @@ -158,7 +159,7 @@ public static bool EmitImplType(IndentedTextWriter writer, ProjectionEmitContext return true; } - if (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) + if (type.IsExclusiveTo && !context.Settings.PublicExclusiveTo) { // one interface impl on the exclusive_to class is marked [Overridable] and matches // this interface. Otherwise the Impl wouldn't be reachable as a CCW. @@ -218,7 +219,7 @@ internal static void WriteClassMarshallerStub(IndentedTextWriter writer, Project // For unsealed classes, the ConvertToUnmanaged path needs to know whether the default interface is // exclusive-to. TypeDefinition? defaultIfaceTd = defaultIface?.ResolveAsTypeDefinition(context.Cache); - bool defaultIfaceIsExclusive = defaultIfaceTd is not null && TypeCategorization.IsExclusiveTo(defaultIfaceTd); + bool defaultIfaceIsExclusive = defaultIfaceTd is not null && defaultIfaceTd.IsExclusiveTo; // Public *Marshaller class writer.WriteLine(isMultiline: true, $$""" diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 3ffdf174c..5182c7c01 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -36,7 +36,7 @@ public static void WriteAbiInterface(IndentedTextWriter writer, ProjectionEmitCo WriteInterfaceMarshallerStub(writer, context, type); // For internal projections, just the static ABI methods class is enough. - if (TypeCategorization.IsProjectionInternal(type)) + if (type.IsProjectionInternal) { return; } @@ -431,7 +431,7 @@ void EmitOneDoAbi(MethodDefinition method) /// public static void WriteInterfaceMarshaller(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - if (TypeCategorization.IsExclusiveTo(type)) + if (type.IsExclusiveTo) { return; } @@ -477,8 +477,8 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj // exclusive to a class (and not opted into PublicExclusiveTo) or if it's marked // [ProjectionInternal]; public otherwise. - bool useInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) - || TypeCategorization.IsProjectionInternal(type); + bool useInternal = (type.IsExclusiveTo && !context.Settings.PublicExclusiveTo) + || type.IsProjectionInternal; // Fast ABI: if this interface is a non-default exclusive-to interface of a fast-abi // class, skip emitting it entirely — its members are merged into the default @@ -493,7 +493,7 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj // is manually projected in WinRT.Runtime, e.g. IColorHelperStatics for ColorHelper, // IColorsStatics for Colors, IFontWeightsStatics for FontWeights). the original code also // omits these because their owning class is not projected. - if (TypeCategorization.IsExclusiveTo(type)) + if (type.IsExclusiveTo) { TypeDefinition? owningClass = AbiTypeHelpers.GetExclusiveToType(context.Cache, type); @@ -506,7 +506,7 @@ private static void WriteInterfaceMarshallerStub(IndentedTextWriter writer, Proj // are inlined in the RCW class, so we skip emitting them in the Methods type. bool skipExclusiveEvents = false; - if (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) + if (type.IsExclusiveTo && !context.Settings.PublicExclusiveTo) { TypeDefinition? classType = AbiTypeHelpers.GetExclusiveToType(context.Cache, type); diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs index b7eec64e6..00b2689f6 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceIDicFactory.cs @@ -26,7 +26,7 @@ internal static class AbiInterfaceIDicFactory /// public static void WriteInterfaceIdicImpl(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - if (TypeCategorization.IsExclusiveTo(type) && !context.Settings.IdicExclusiveTo) + if (type.IsExclusiveTo && !context.Settings.IdicExclusiveTo) { return; } diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 79e6cb695..f389e0384 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -130,7 +130,7 @@ public static (TypeDefinition? DefaultInterface, System.Collections.Generic.List { defaultIface = ifaceTd; } - else if (TypeCategorization.IsExclusiveTo(ifaceTd)) + else if (ifaceTd.IsExclusiveTo) { exclusiveIfaces.Add(ifaceTd); } diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs index 9dfe275c5..b837f307f 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.WriteInterfaceMembers.cs @@ -195,7 +195,7 @@ private static void WriteInterfaceMembers(IndentedTextWriter writer, ProjectionE // into the default interface's vtable in a fixed order TypeDefinition abiInterface = ifaceType; ITypeDefOrRef abiInterfaceRef = originalInterface; - bool isFastAbiExclusive = ClassFactory.IsFastAbiClass(classType) && TypeCategorization.IsExclusiveTo(ifaceType); + bool isFastAbiExclusive = ClassFactory.IsFastAbiClass(classType) && ifaceType.IsExclusiveTo; bool isDefaultInterface = false; if (isFastAbiExclusive) diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index e7df4fda8..9f5f45fe7 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -52,7 +52,7 @@ internal static bool IsInterfaceInInheritanceList(MetadataCache cache, Interface return true; } - return !TypeCategorization.IsExclusiveTo(td); + return !td.IsExclusiveTo; } /// diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index bfbc2ca18..97484f5c7 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -11,6 +11,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -30,10 +31,10 @@ public static void AddMetadataTypeEntry(ProjectionEmitContext context, TypeDefin return; } - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); if ((cat == TypeKind.Class && type.IsStatic) || - (cat == TypeKind.Interface && TypeCategorization.IsExclusiveTo(type))) + (cat == TypeKind.Interface && type.IsExclusiveTo)) { return; } diff --git a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs index 867d3212a..86a4f939e 100644 --- a/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/InterfaceFactory.cs @@ -99,13 +99,13 @@ public static void WriteTypeInheritance(IndentedTextWriter writer, ProjectionEmi if (impl.Interface is TypeDefinition ifaceTypeDef) { - isExclusive = TypeCategorization.IsExclusiveTo(ifaceTypeDef); + isExclusive = ifaceTypeDef.IsExclusiveTo; } else { if (impl.TryResolveTypeDef(context.Cache, out TypeDefinition? resolved)) { - isExclusive = TypeCategorization.IsExclusiveTo(resolved); + isExclusive = resolved.IsExclusiveTo; } } @@ -389,14 +389,14 @@ public static void WriteInterface(IndentedTextWriter writer, ProjectionEmitConte // public_exclusiveto is set (or in reference projection or component mode). if (!context.Settings.ReferenceProjection && !context.Settings.Component && - TypeCategorization.IsExclusiveTo(type) && + type.IsExclusiveTo && !context.Settings.PublicExclusiveTo && !IsDefaultOrOverridableInterfaceTypedef(context.Cache, type)) { return; } - if (context.Settings.Component && !TypeCategorization.IsExclusiveTo(type)) + if (context.Settings.Component && !type.IsExclusiveTo) { return; } @@ -410,8 +410,8 @@ public static void WriteInterface(IndentedTextWriter writer, ProjectionEmitConte """); CustomAttributeFactory.WriteTypeCustomAttributes(writer, context, type, false); - bool isInternal = (TypeCategorization.IsExclusiveTo(type) && !context.Settings.PublicExclusiveTo) || - TypeCategorization.IsProjectionInternal(type); + bool isInternal = (type.IsExclusiveTo && !context.Settings.PublicExclusiveTo) || + type.IsProjectionInternal; WriteTypedefNameWithTypeParamsCallback name = TypedefNameWriter.WriteTypedefNameWithTypeParams(context, type, TypedefNameType.CCW, false); WriteTypeInheritanceCallback inheritance = WriteTypeInheritance(context, type, false, false); writer.WriteLine($"{(isInternal ? "internal" : "public")} interface {name}{inheritance}"); @@ -425,7 +425,7 @@ public static void WriteInterface(IndentedTextWriter writer, ProjectionEmitConte /// [Overridable] interface impl on the class it's exclusive to. private static bool IsDefaultOrOverridableInterfaceTypedef(MetadataCache cache, TypeDefinition iface) { - if (!TypeCategorization.IsExclusiveTo(iface)) + if (!iface.IsExclusiveTo) { return false; } diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index a4a6eaff5..03753266c 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -13,6 +13,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -294,7 +295,7 @@ public static void WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(Indent { // Skip exclusive interfaces and projection-internal interfaces. if (type.IsInterface && - (TypeCategorization.IsExclusiveTo(type) || TypeCategorization.IsProjectionInternal(type))) + (type.IsExclusiveTo || type.IsProjectionInternal)) { return; } @@ -339,7 +340,7 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe WriteTypeMapAttribute(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"\"{value}\"", $"typeof({target})", $"typeof({projectionName})"); // For non-interface, non-struct authored types, emit proxy association. - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); if (cat is not (TypeKind.Interface or TypeKind.Struct) && context.Settings.Component) { @@ -364,8 +365,8 @@ public static void WriteWinRTIdicTypeMapGroupAssemblyAttribute(IndentedTextWrite } // Skip exclusive interfaces (unless idic_exclusiveto), and projection-internal types. - if ((TypeCategorization.IsExclusiveTo(type) && !context.Settings.IdicExclusiveTo) || - TypeCategorization.IsProjectionInternal(type)) + if ((type.IsExclusiveTo && !context.Settings.IdicExclusiveTo) || + type.IsProjectionInternal) { return; } @@ -491,7 +492,7 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, continue; } - if (TypeCategorization.IsExclusiveTo(ifaceDef)) + if (ifaceDef.IsExclusiveTo) { // Resolve TypeReference -> TypeDefinition so WriteTypeName goes through the // Definition branch which knows about authored-type CCW namespacing. diff --git a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs index 90b3a6b63..6c65e0948 100644 --- a/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ReferenceImplFactory.cs @@ -8,6 +8,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -109,7 +110,7 @@ public static int get_Value(void* thisPtr, void* result) } """); } - else if (TypeCategorization.GetCategory(type) is TypeKind.Class or TypeKind.Delegate) + else if (TypeKindResolver.Resolve(type) is TypeKind.Class or TypeKind.Delegate) { // Non-blittable runtime class / delegate: marshal via Marshaller and detach. WriteProjectedSignatureCallback projectedName = MethodFactory.WriteProjectedSignature(context, type.ToTypeSignature(), false); @@ -140,7 +141,7 @@ public static int get_Value(void* thisPtr, void* result) // Defensive: should be unreachable. WriteReferenceImpl is only called for enum/struct/delegate // types (WriteAbiEnum / WriteAbiStruct / WriteAbiDelegate dispatchers). throw WellKnownProjectionWriterExceptions.UnreachableEmissionState( - $"WriteReferenceImpl: unsupported type category {TypeCategorization.GetCategory(type)} " + + $"WriteReferenceImpl: unsupported type category {TypeKindResolver.Resolve(type)} " + $"for type '{type.FullName}'. Expected enum/struct/delegate."); } diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index fcfcdf297..7e4878b1d 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -9,6 +9,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Factories; @@ -41,7 +42,7 @@ private static IEnumerable GetInstanceFields(TypeDefinition typ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); // A struct field is "blittable" when its projected and ABI layouts match (no per-field // marshalling). Detect that via AbiTypeKindResolver.IsBlittableStruct: it returns true diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs index 605592d9a..6ff3a0e69 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs @@ -9,6 +9,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Generation; @@ -97,7 +98,7 @@ internal void WriteGeneratedInterfaceIidsFile() } iidWritten = true; - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); switch (cat) { case TypeKind.Delegate: diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index a8ee6844b..e90b6aa03 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -10,6 +10,7 @@ using WindowsRuntime.ProjectionWriter.Helpers; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Generation; @@ -60,7 +61,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); switch (cat) { case TypeKind.Class: @@ -90,7 +91,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe MetadataAttributeFactory.WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(writer, context, type); break; case TypeKind.Struct: - if (!TypeCategorization.IsApiContractType(type)) + if (!type.IsApiContractType) { MetadataAttributeFactory.WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(writer, context, type, true); MetadataAttributeFactory.WriteWinRTWindowsMetadataTypeMapGroupAssemblyAttribute(writer, context, type); @@ -125,7 +126,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe } // Write the projected type per category - TypeKind category = TypeCategorization.GetCategory(type); + TypeKind category = TypeKindResolver.Resolve(type); ProjectionFileBuilder.WriteType(writer, context, type, category); if (category == TypeKind.Class && !type.IsAttributeType) @@ -143,7 +144,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe { ComponentFactory.AddMetadataTypeEntry(context, type, authoredTypeNameToMetadataMap); } - else if (category == TypeKind.Struct && !TypeCategorization.IsApiContractType(type)) + else if (category == TypeKind.Struct && !type.IsApiContractType) { ComponentFactory.AddMetadataTypeEntry(context, type, authoredTypeNameToMetadataMap); } @@ -175,7 +176,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - if (TypeCategorization.GetCategory(type) != TypeKind.Class) + if (TypeKindResolver.Resolve(type) != TypeKind.Class) { continue; } @@ -216,7 +217,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - if (TypeCategorization.IsApiContractType(type)) + if (type.IsApiContractType) { continue; } @@ -226,7 +227,7 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - TypeKind category = TypeCategorization.GetCategory(type); + TypeKind category = TypeKindResolver.Resolve(type); ProjectionFileBuilder.WriteAbiType(writer, context, type, category); } writer.WriteEndAbiNamespace(context); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 2b339bb4b..e8e2f139c 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -6,6 +6,7 @@ using AsmResolver.PE.DotNet.Metadata.Tables; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -16,7 +17,7 @@ internal static partial class AbiTypeHelpers /// public static bool IsTypeBlittable(MetadataCache cache, TypeDefinition type) { - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); if (cat == TypeKind.Enum) { @@ -177,7 +178,7 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur // Same-module: use the resolved category directly. if (td.Type is TypeDefinition def) { - TypeKind cat = TypeCategorization.GetCategory(def); + TypeKind cat = TypeKindResolver.Resolve(def); return cat is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } @@ -190,7 +191,7 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur if (resolved is not null) { - TypeKind cat = TypeCategorization.GetCategory(resolved); + TypeKind cat = TypeKindResolver.Resolve(resolved); return cat is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 7654b4b6a..23e821142 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -8,6 +8,7 @@ using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; using WindowsRuntime.ProjectionWriter.References; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; using static WindowsRuntime.ProjectionWriter.References.ProjectionNames; using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; @@ -140,7 +141,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext if (rd is not null) { - TypeKind cat = TypeCategorization.GetCategory(rd); + TypeKind cat = TypeKindResolver.Resolve(rd); if (cat == TypeKind.Enum) { diff --git a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs index 5ad48dfb9..ae39d3b98 100644 --- a/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/ObjRefNameGenerator.cs @@ -279,7 +279,7 @@ public static void WriteClassObjRefDefinitions(IndentedTextWriter writer, Projec { TypeDefinition? implTypeDef = impl.Interface.ResolveAsTypeDefinition(context.Cache); - if (implTypeDef is not null && TypeCategorization.IsExclusiveTo(implTypeDef)) + if (implTypeDef is not null && implTypeDef.IsExclusiveTo) { continue; } @@ -307,7 +307,7 @@ public static void WriteClassObjRefDefinitions(IndentedTextWriter writer, Projec { TypeDefinition? implTypeDef = impl.Interface.ResolveAsTypeDefinition(context.Cache); - if (implTypeDef is not null && TypeCategorization.IsExclusiveTo(implTypeDef)) + if (implTypeDef is not null && implTypeDef.IsExclusiveTo) { continue; } diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs index d706d0c7d..e91693aea 100644 --- a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -6,6 +6,7 @@ using WindowsRuntime.ProjectionWriter.Generation; using WindowsRuntime.ProjectionWriter.Metadata; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; using WindowsRuntime.ProjectionWriter.Writers; namespace WindowsRuntime.ProjectionWriter.Helpers; @@ -165,7 +166,7 @@ private static void WriteSignature(IndentedTextWriter writer, ProjectionEmitCont /// The type to emit a signature for. private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - TypeKind cat = TypeCategorization.GetCategory(type); + TypeKind cat = TypeKindResolver.Resolve(type); switch (cat) { case TypeKind.Enum: diff --git a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs index cb0d544cd..9634e3697 100644 --- a/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/TypedefNameWriter.cs @@ -71,7 +71,7 @@ public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitCon TypedefNameType nameToWrite = nameType; - if (authoredType && TypeCategorization.IsExclusiveTo(type) && nameToWrite == TypedefNameType.Projected) + if (authoredType && type.IsExclusiveTo && nameToWrite == TypedefNameType.Projected) { nameToWrite = TypedefNameType.CCW; } @@ -79,7 +79,7 @@ public static void WriteTypedefName(IndentedTextWriter writer, ProjectionEmitCon // Authored interfaces that aren't exclusive use the same authored interface. if (authoredType && nameToWrite == TypedefNameType.CCW && type.IsInterface && - !TypeCategorization.IsExclusiveTo(type)) + !type.IsExclusiveTo) { nameToWrite = TypedefNameType.Projected; } diff --git a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs index 3c5cc3e1f..6e5fe03f6 100644 --- a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs +++ b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using AsmResolver.DotNet; using WindowsRuntime.ProjectionWriter.Models; +using WindowsRuntime.ProjectionWriter.Resolvers; namespace WindowsRuntime.ProjectionWriter.Metadata; @@ -47,7 +48,7 @@ internal sealed class NamespaceMembers(string name) public void AddType(TypeDefinition type) { Types.Add(type); - TypeKind category = TypeCategorization.GetCategory(type); + TypeKind category = TypeKindResolver.Resolve(type); switch (category) { case TypeKind.Interface: @@ -68,7 +69,7 @@ public void AddType(TypeDefinition type) Enums.Add(type); break; case TypeKind.Struct: - if (TypeCategorization.IsApiContractType(type)) + if (type.IsApiContractType) { Contracts.Add(type); } diff --git a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs b/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs deleted file mode 100644 index fdd1b27ac..000000000 --- a/src/WinRT.Projection.Writer/Metadata/TypeCategorization.cs +++ /dev/null @@ -1,55 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -using AsmResolver.DotNet; -using WindowsRuntime.ProjectionWriter.Models; -using static WindowsRuntime.ProjectionWriter.References.WellKnownAttributeNames; -using static WindowsRuntime.ProjectionWriter.References.WellKnownNamespaces; - -namespace WindowsRuntime.ProjectionWriter.Metadata; - -/// -/// Static type categorization helpers, mirroring winmd::reader::get_category and various -/// -internal static class TypeCategorization -{ - /// - /// Determines a type's category (class/interface/enum/struct/delegate). - /// - public static TypeKind GetCategory(TypeDefinition type) - { - return type switch - { - { IsInterface: true } => TypeKind.Interface, - { IsEnum: true } => TypeKind.Enum, - { IsValueType: true } => TypeKind.Struct, - { IsDelegate: true } => TypeKind.Delegate, - _ => TypeKind.Class - }; - } - - /// - /// True if this is an API contract struct type. - /// - public static bool IsApiContractType(TypeDefinition type) - { - return type.IsStruct && type.HasAttribute(WindowsFoundationMetadata, "ApiContractAttribute"); - } - - /// - /// True if this is an interface marked [ExclusiveTo]. - /// - public static bool IsExclusiveTo(TypeDefinition type) - { - return type.IsInterface && type.HasAttribute(WindowsFoundationMetadata, ExclusiveToAttribute); - } - - /// - /// True if this type is marked [ProjectionInternal]. - /// - public static bool IsProjectionInternal(TypeDefinition type) - { - return type.HasAttribute(WindowsRuntimeInternal, "ProjectionInternalAttribute"); - } -} - diff --git a/src/WinRT.Projection.Writer/Resolvers/TypeKindResolver.cs b/src/WinRT.Projection.Writer/Resolvers/TypeKindResolver.cs new file mode 100644 index 000000000..409cd1c56 --- /dev/null +++ b/src/WinRT.Projection.Writer/Resolvers/TypeKindResolver.cs @@ -0,0 +1,31 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +using AsmResolver.DotNet; +using WindowsRuntime.ProjectionWriter.Models; + +namespace WindowsRuntime.ProjectionWriter.Resolvers; + +/// +/// Classifies a into one of the five fundamental WinRT +/// type kinds (): class, interface, enum, struct, or delegate. +/// +internal static class TypeKindResolver +{ + /// + /// Returns the for . + /// + /// The type definition to classify. + /// The resolved . + public static TypeKind Resolve(TypeDefinition type) + { + return type switch + { + { IsInterface: true } => TypeKind.Interface, + { IsEnum: true } => TypeKind.Enum, + { IsValueType: true } => TypeKind.Struct, + { IsDelegate: true } => TypeKind.Delegate, + _ => TypeKind.Class + }; + } +} From 4e4b310dafb117acfa0982a2928d8c0cf94673ec Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 11:37:53 -0700 Subject: [PATCH 168/171] Add per-member XML docs to TypeKind; small polish to related helpers Polish pass over the type-kind helpers introduced in the previous three commits: - Add per-member XML docs to TypeKind (Interface, Class, Enum, Struct, Delegate). - Strongly-type WellKnownProjectionWriterExceptions.UnknownTypeKind to accept TypeKind instead of object, and refine the error message text. - Simplify TypeDefinitionExtensions.IsStatic to 'type.IsAbstract && type.IsSealed' (the explicit non-class short-circuit is unnecessary: in IL, only classes can be both abstract and sealed - enums/structs/delegates are sealed but not abstract, and interfaces are abstract but not sealed). - Trim the IsAttributeType to drop the redundant 'WinMD attribute types always extend Attribute directly' sentence (the immediate-base restriction is already clearly stated). - Drop a stray trailing blank line in AbiTypeHelpers.cs. Build clean (0 warnings); validation harness reports 0 diffs across all 3 regen scenarios (pushnot, everything-with-ui, windows). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../WellKnownProjectionWriterExceptions.cs | 5 +++-- .../Extensions/TypeDefinitionExtensions.cs | 19 +++-------------- .../Helpers/AbiTypeHelpers.cs | 1 - .../Models/TypeKind.cs | 21 ++++++++++++++++++- 4 files changed, 26 insertions(+), 20 deletions(-) diff --git a/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs b/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs index c8224c10e..6044cb38b 100644 --- a/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs +++ b/src/WinRT.Projection.Writer/Errors/WellKnownProjectionWriterExceptions.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using System; +using WindowsRuntime.ProjectionWriter.Models; namespace WindowsRuntime.ProjectionWriter.Errors; @@ -20,9 +21,9 @@ internal static class WellKnownProjectionWriterExceptions /// /// A switch over the well-known TypeKind enum encountered an unrecognized member. /// - public static WellKnownProjectionWriterException UnknownTypeKind(object kind) + public static WellKnownProjectionWriterException UnknownTypeKind(TypeKind kind) { - return Exception(5003, $"Unknown TypeKind: {kind}."); + return Exception(5003, $"Unknown type kind: '{kind}'."); } /// diff --git a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs index 4b3eb89d6..79cf0e43a 100644 --- a/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs +++ b/src/WinRT.Projection.Writer/Extensions/TypeDefinitionExtensions.cs @@ -30,8 +30,7 @@ internal static class TypeDefinitionExtensions /// /// This check only inspects the type's immediate base. Types that inherit /// through an intermediate base class are reported as - /// . WinMD attribute types always extend - /// directly, so this matches their shape exactly. + /// . /// public bool IsAttributeType { @@ -54,21 +53,9 @@ public bool IsAttributeType } /// - /// Returns whether the type is a static class (i.e. a class that is both - /// abstract and sealed). + /// Returns whether the type is static. /// - public bool IsStatic - { - get - { - if (type.IsInterface || type.IsValueType || type.IsDelegate) - { - return false; - } - - return type.IsAbstract && type.IsSealed; - } - } + public bool IsStatic => type.IsAbstract && type.IsSealed; /// /// Returns whether the type is an enum marked with [System.FlagsAttribute]. diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs index 0aed288ac..b2bcd2a1f 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.cs @@ -218,5 +218,4 @@ public static bool InterfacesEqualByName(TypeDefinition a, TypeDefinition b) { return a == b || a.Names() == b.Names(); } - } diff --git a/src/WinRT.Projection.Writer/Models/TypeKind.cs b/src/WinRT.Projection.Writer/Models/TypeKind.cs index c20ecb5ab..bdbca19d4 100644 --- a/src/WinRT.Projection.Writer/Models/TypeKind.cs +++ b/src/WinRT.Projection.Writer/Models/TypeKind.cs @@ -4,13 +4,32 @@ namespace WindowsRuntime.ProjectionWriter.Models; /// -/// Categorization of a Windows Runtime type definition. +/// Indicates the kind of a given type definition. /// internal enum TypeKind { + /// + /// The type is an interface. + /// Interface, + + /// + /// The type is a class (including static classes and runtime classes). + /// Class, + + /// + /// The type is an enum. + /// Enum, + + /// + /// The type is a struct (a non-enum value type). + /// Struct, + + /// + /// The type is a delegate. + /// Delegate, } From b766080d9470ec9e3b4702560f53301d6ac73d9f Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 11:41:34 -0700 Subject: [PATCH 169/171] Rename TypeKind variables to 'kind' Rename local and parameter variables named 'category'/'cat' to 'kind' across the projection writer codebase for naming consistency. Updated parameter names in ProjectionFileBuilder, adjusted switch statements and exception calls, and replaced local usages in AbiClassFactory, ComponentFactory, MetadataAttributeFactory, StructEnumMarshallerFactory, ProjectionGenerator (Namespace and GeneratedIids), AbiTypeHelpers.Blittability, AbiTypeWriter, SignatureGenerator, and NamespaceMembers. No functional changes intended. --- .../Builders/ProjectionFileBuilder.cs | 12 +++++------ .../Factories/AbiClassFactory.cs | 8 ++++---- .../Factories/ComponentFactory.cs | 6 +++--- .../Factories/MetadataAttributeFactory.cs | 4 ++-- .../Factories/StructEnumMarshallerFactory.cs | 10 +++++----- .../ProjectionGenerator.GeneratedIids.cs | 4 ++-- .../ProjectionGenerator.Namespace.cs | 20 +++++++++---------- .../Helpers/AbiTypeHelpers.Blittability.cs | 14 ++++++------- .../Helpers/AbiTypeWriter.cs | 6 +++--- .../Helpers/SignatureGenerator.cs | 4 ++-- .../Metadata/NamespaceMembers.cs | 4 ++-- 11 files changed, 46 insertions(+), 46 deletions(-) diff --git a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs index 563e3ac38..6e43119d1 100644 --- a/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs +++ b/src/WinRT.Projection.Writer/Builders/ProjectionFileBuilder.cs @@ -23,9 +23,9 @@ internal static class ProjectionFileBuilder /// /// Dispatches type emission based on the type category. /// - public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeKind category) + public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeKind kind) { - switch (category) + switch (kind) { case TypeKind.Class when type.IsAttributeType: WriteAttribute(writer, context, type); @@ -49,16 +49,16 @@ public static void WriteType(IndentedTextWriter writer, ProjectionEmitContext co WriteStruct(writer, context, type); break; default: - throw WellKnownProjectionWriterExceptions.UnknownTypeKind(category); + throw WellKnownProjectionWriterExceptions.UnknownTypeKind(kind); } } /// /// Dispatches ABI emission based on the type category. /// - public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeKind category) + public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type, TypeKind kind) { - switch (category) + switch (kind) { case TypeKind.Class: AbiClassFactory.WriteAbiClass(writer, context, type); @@ -77,7 +77,7 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext AbiStructFactory.WriteAbiStruct(writer, context, type); break; default: - throw WellKnownProjectionWriterExceptions.UnknownTypeKind(category); + throw WellKnownProjectionWriterExceptions.UnknownTypeKind(kind); } } diff --git a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs index 4be813f62..ccd5c359e 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiClassFactory.cs @@ -120,24 +120,24 @@ internal static void WriteAuthoringMetadataType(IndentedTextWriter writer, Proje string typeNs = type.GetRawNamespace(); string projectedType = TypedefNameWriter.BuildGlobalQualifiedName(typeNs, nameStripped); string fullName = string.IsNullOrEmpty(typeNs) ? nameStripped : $"{typeNs}.{nameStripped}"; - TypeKind category = TypeKindResolver.Resolve(type); + TypeKind kind = TypeKindResolver.Resolve(type); // [WindowsRuntimeReferenceType(typeof(?))] for non-delegate, non-class types // (i.e. enums, structs, interfaces). - if (category is not (TypeKind.Delegate or TypeKind.Class)) + if (kind is not (TypeKind.Delegate or TypeKind.Class)) { writer.WriteLine($"[WindowsRuntimeReferenceType(typeof({projectedType}?))]"); } // [ABI..ComWrappersMarshaller] for non-struct, non-class types // (delegates, enums, interfaces). - if (category is not (TypeKind.Struct or TypeKind.Class)) + if (kind is not (TypeKind.Struct or TypeKind.Class)) { writer.WriteLine($"[ABI.{typeNs}.{nameStripped}ComWrappersMarshaller]"); } // [WindowsRuntimeClassName("Windows.Foundation.IReference`1<.>")] for non-class types. - if (category != TypeKind.Class) + if (kind != TypeKind.Class) { writer.WriteLine($"[WindowsRuntimeClassName(\"Windows.Foundation.IReference`1<{fullName}>\")]"); } diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 97484f5c7..3d3112d80 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -31,10 +31,10 @@ public static void AddMetadataTypeEntry(ProjectionEmitContext context, TypeDefin return; } - TypeKind cat = TypeKindResolver.Resolve(type); + TypeKind kind = TypeKindResolver.Resolve(type); - if ((cat == TypeKind.Class && type.IsStatic) || - (cat == TypeKind.Interface && type.IsExclusiveTo)) + if ((kind == TypeKind.Class && type.IsStatic) || + (kind == TypeKind.Interface && type.IsExclusiveTo)) { return; } diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 03753266c..6b4e703d8 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -340,9 +340,9 @@ public static void WriteWinRTComWrappersTypeMapGroupAssemblyAttribute(IndentedTe WriteTypeMapAttribute(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"\"{value}\"", $"typeof({target})", $"typeof({projectionName})"); // For non-interface, non-struct authored types, emit proxy association. - TypeKind cat = TypeKindResolver.Resolve(type); + TypeKind kind = TypeKindResolver.Resolve(type); - if (cat is not (TypeKind.Interface or TypeKind.Struct) && context.Settings.Component) + if (kind is not (TypeKind.Interface or TypeKind.Struct) && context.Settings.Component) { WriteTypeMapAssociation(writer, "WindowsRuntimeComWrappersTypeMapGroup", $"typeof({projectionName})", $"typeof({target})"); writer.WriteLine(); diff --git a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs index 7e4878b1d..272354104 100644 --- a/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/StructEnumMarshallerFactory.cs @@ -42,20 +42,20 @@ private static IEnumerable GetInstanceFields(TypeDefinition typ internal static void WriteStructEnumMarshallerClass(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { string nameStripped = type.GetStrippedName(); - TypeKind cat = TypeKindResolver.Resolve(type); + TypeKind kind = TypeKindResolver.Resolve(type); // A struct field is "blittable" when its projected and ABI layouts match (no per-field // marshalling). Detect that via AbiTypeKindResolver.IsBlittableStruct: it returns true // for self-mapped structs with RequiresMarshaling=false and for user structs whose // fields are all blittable. TypeDefOrRefSignature sig = type.ToTypeSignature(false) is TypeDefOrRefSignature td2 ? td2 : null!; - bool blittableStruct = cat == TypeKind.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); - bool isEnum = cat == TypeKind.Enum; + bool blittableStruct = kind == TypeKind.Struct && (sig is null || context.AbiTypeKindResolver.IsBlittableStruct(sig)); + bool isEnum = kind == TypeKind.Enum; // Complex structs are the remaining (non-blittable, non-mapped) structs that need a // per-field marshaller class because at least one field is a reference type, generic // instance, or marshalling-mapped value. - bool isNonBlittableStruct = cat == TypeKind.Struct && !blittableStruct; + bool isNonBlittableStruct = kind == TypeKind.Struct && !blittableStruct; // Detect Nullable reference fields to determine whether the struct's BoxToUnmanaged // call needs CreateComInterfaceFlags.TrackerSupport . @@ -346,7 +346,7 @@ file static class {{nameStripped}}InterfaceEntriesImpl // is NOT emitted for STRUCTS (the attribute is supplied by cswinrtgen instead). Enums // and other types still emit it from write_abi_enum/etc. - if (context.Settings.Component && cat == TypeKind.Struct) + if (context.Settings.Component && kind == TypeKind.Struct) { return; } diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs index 6ff3a0e69..62fd1b734 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.GeneratedIids.cs @@ -98,8 +98,8 @@ internal void WriteGeneratedInterfaceIidsFile() } iidWritten = true; - TypeKind cat = TypeKindResolver.Resolve(type); - switch (cat) + TypeKind kind = TypeKindResolver.Resolve(type); + switch (kind) { case TypeKind.Delegate: IidExpressionGenerator.WriteIidGuidPropertyFromSignature(guidIndented, guidContext, type); diff --git a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs index e90b6aa03..5275e3681 100644 --- a/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs +++ b/src/WinRT.Projection.Writer/Generation/ProjectionGenerator.Namespace.cs @@ -61,8 +61,8 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - TypeKind cat = TypeKindResolver.Resolve(type); - switch (cat) + TypeKind kind = TypeKindResolver.Resolve(type); + switch (kind) { case TypeKind.Class: if (!type.IsStatic && !type.IsAttributeType) @@ -125,11 +125,11 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - // Write the projected type per category - TypeKind category = TypeKindResolver.Resolve(type); - ProjectionFileBuilder.WriteType(writer, context, type, category); + // Write the projected type per type kind + TypeKind kind = TypeKindResolver.Resolve(type); + ProjectionFileBuilder.WriteType(writer, context, type, kind); - if (category == TypeKind.Class && !type.IsAttributeType) + if (kind == TypeKind.Class && !type.IsAttributeType) { MetadataAttributeFactory.AddDefaultInterfaceEntry(context, type, defaultInterfaceEntries); MetadataAttributeFactory.AddExclusiveToInterfaceEntries(context, type, exclusiveToInterfaceEntries); @@ -140,11 +140,11 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe ComponentFactory.WriteFactoryClass(writer, context, type); } } - else if (category is TypeKind.Delegate or TypeKind.Enum or TypeKind.Interface) + else if (kind is TypeKind.Delegate or TypeKind.Enum or TypeKind.Interface) { ComponentFactory.AddMetadataTypeEntry(context, type, authoredTypeNameToMetadataMap); } - else if (category == TypeKind.Struct && !type.IsApiContractType) + else if (kind == TypeKind.Struct && !type.IsApiContractType) { ComponentFactory.AddMetadataTypeEntry(context, type, authoredTypeNameToMetadataMap); } @@ -227,8 +227,8 @@ internal bool ProcessNamespace(string ns, NamespaceMembers members, ProjectionGe continue; } - TypeKind category = TypeKindResolver.Resolve(type); - ProjectionFileBuilder.WriteAbiType(writer, context, type, category); + TypeKind kind = TypeKindResolver.Resolve(type); + ProjectionFileBuilder.WriteAbiType(writer, context, type, kind); } writer.WriteEndAbiNamespace(context); } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index e8e2f139c..12ec39873 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -17,14 +17,14 @@ internal static partial class AbiTypeHelpers /// public static bool IsTypeBlittable(MetadataCache cache, TypeDefinition type) { - TypeKind cat = TypeKindResolver.Resolve(type); + TypeKind kind = TypeKindResolver.Resolve(type); - if (cat == TypeKind.Enum) + if (kind == TypeKind.Enum) { return true; } - if (cat != TypeKind.Struct) + if (kind != TypeKind.Struct) { return false; } @@ -178,8 +178,8 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur // Same-module: use the resolved category directly. if (td.Type is TypeDefinition def) { - TypeKind cat = TypeKindResolver.Resolve(def); - return cat is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; + TypeKind kind = TypeKindResolver.Resolve(def); + return kind is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } // Cross-module typeref: try to resolve via the metadata cache to check category @@ -191,8 +191,8 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur if (resolved is not null) { - TypeKind cat = TypeKindResolver.Resolve(resolved); - return cat is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; + TypeKind kind = TypeKindResolver.Resolve(resolved); + return kind is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 23e821142..8484f679c 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -141,16 +141,16 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext if (rd is not null) { - TypeKind cat = TypeKindResolver.Resolve(rd); + TypeKind kind = TypeKindResolver.Resolve(rd); - if (cat == TypeKind.Enum) + if (kind == TypeKind.Enum) { // Enums use the projected enum type directly (C# layout == ABI layout). TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); break; } - if (cat == TypeKind.Struct) + if (kind == TypeKind.Struct) { // Special case: HResult is mapped to System.Exception (a reference type) // but its ABI representation is the global::ABI.System.Exception struct diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs index e91693aea..9ac781df6 100644 --- a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -166,8 +166,8 @@ private static void WriteSignature(IndentedTextWriter writer, ProjectionEmitCont /// The type to emit a signature for. private static void WriteSignatureForType(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - TypeKind cat = TypeKindResolver.Resolve(type); - switch (cat) + TypeKind kind = TypeKindResolver.Resolve(type); + switch (kind) { case TypeKind.Enum: writer.Write("enum("); diff --git a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs index 6e5fe03f6..563fddbe7 100644 --- a/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs +++ b/src/WinRT.Projection.Writer/Metadata/NamespaceMembers.cs @@ -48,8 +48,8 @@ internal sealed class NamespaceMembers(string name) public void AddType(TypeDefinition type) { Types.Add(type); - TypeKind category = TypeKindResolver.Resolve(type); - switch (category) + TypeKind kind = TypeKindResolver.Resolve(type); + switch (kind) { case TypeKind.Interface: Interfaces.Add(type); From f21c8d3226d76a6b7327e524e9736084ff38ca28 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 16:33:21 -0700 Subject: [PATCH 170/171] Fix CS1014 in static factory objref property: restore missing 'get' accessor Commit 490787a9 ('Reference-projection events & static factory') refactored WriteStaticFactoryObjRef from a single-block emitter that always opened the property body with 'get { ... }' into two separate code paths (reference projection vs non-reference). The non-reference path lost the 'get' keyword while keeping the property's outer '{ ... }' braces, so the emitted property body became a bare block: private static WindowsRuntimeObjectReference _objRef_X { var __X = field; // <- CS1014 here if (...) return __X; return field = WindowsRuntimeObjectReference.GetActivationFactory(...); } This is what the failing CI was reporting as 'CS1014: A get or set accessor expected' across many of the per-namespace projection files (Windows.Management.Update.cs, Windows.ApplicationModel.Background.cs, Windows.AI.MachineLearning.cs, etc.). Restore the 'get { ... }' accessor wrapper around the body so the generated property compiles. The reference-projection branch (added in 490787a9) is unaffected because it uses an expression-bodied property ('=> throw null;') which doesn't need accessor braces. Verified locally: build succeeds with 0 warnings; the validation harness reports the expected ~640 diffs across pushnot / everything-with-ui / windows scenarios - every single one of which is exactly the missing 'get' accessor being added back to a static factory objref property. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/WinRT.Projection.Writer/Factories/ClassFactory.cs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index f389e0384..64c589e58 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -472,12 +472,15 @@ internal static void WriteStaticFactoryObjRef(IndentedTextWriter writer, Project writer.WriteLine(isMultiline: true, $$""" private static WindowsRuntimeObjectReference {{objRefName}} { - var __{{objRefName}} = field; - if (__{{objRefName}} != null && __{{objRefName}}.IsInCurrentContext) + get { - return __{{objRefName}}; + var __{{objRefName}} = field; + if (__{{objRefName}} != null && __{{objRefName}}.IsInCurrentContext) + { + return __{{objRefName}}; + } + return field = WindowsRuntimeObjectReference.GetActivationFactory("{{runtimeClassFullName}}", {{iid}}); } - return field = WindowsRuntimeObjectReference.GetActivationFactory("{{runtimeClassFullName}}", {{iid}}); } """); } From 07959c09fea68ceb06e99d9d1790452a90313d20 Mon Sep 17 00:00:00 2001 From: Sergio Pedri Date: Thu, 21 May 2026 17:58:46 -0700 Subject: [PATCH 171/171] Remove unnecessary cache null checks and inline 'context.Cache' uses in the projection writer Sweep the projection writer for unnecessary null checks on the metadata cache: - ProjectionEmitContext.Cache is non-nullable (MetadataCache, not MetadataCache?) and is set from the non-nullable constructor parameter; the various 'MetadataCache cache' parameter sites are non-nullable too. The 'cache is null' / 'cache is not null' / 'context.Cache is null' / 'context.Cache is not null' guards were defensive dead branches. - Also drop the 'MetadataCache cache = context.Cache;' local-variable stashes (in WriteFactoryClass and AbiInterfaceFactory) and just use 'context.Cache' directly at the few call sites; the locals were holding zero state and only obscured the call. Sites cleaned up: - AbiTypeHelpers.AbiTypeNames.cs: 'cache is null ? "int" : GetProjectedEnumName(def)' -> 'GetProjectedEnumName(def)'. - AbiTypeHelpers.Blittability.cs (IsRuntimeClassOrInterface): unwrapped the 'if (cache is not null)' guard around the cross-module resolve. - AbiTypeWriter.cs (Reference case): unwrapped the 'if (context.Cache is not null)' guard; dedented the body; deduped 'var (rns, rname) = r.Type.Names()' (was redeclared inside the now-removed inner scope and inside 'if (r.IsValueType)'). - ClassFactory.WriteStaticClassMembers: dropped the 'if (context.Cache is null) return;' early-out. - ClassFactory (ref-mode synthetic ctor block): 'else if (context.Cache is not null)' -> 'else'. - ClassMembersFactory.WriteInterfaceTypeNameForCcw: dropped the '&& context.Cache is not null' conjunct; promoted the multi-type negation to a single 'is not (TypeDefinition or TypeSpecification)' pattern that the strict analyzer prefers. - ComponentFactory.WriteFactoryClass: removed the 'MetadataCache cache = context.Cache' local and unwrapped the 'if (cache is not null)' block around the factory-member emission loop. - ConstructorFactory.WriteAttributedTypes: dropped the 'if (context.Cache is null) return;' early-out. - MetadataAttributeFactory: four sites - two pattern-match cleanups ('is not TypeDefinition && is not TypeSpecification' -> 'is not (TypeDefinition or TypeSpecification)') and two compound-assignment cleanups ('if (ifaceDef is null) { ifaceDef = ... }' -> 'ifaceDef ??= ...'). - SignatureGenerator (Reference + GenericInstanceRef cases): unwrapped the 'if (context.Cache is not null)' guards; the cache-resolved 'TryResolve(...) ?? Find(...)' expression now runs unconditionally. - AbiInterfaceFactory (component-mode exclusive-to resolution): removed the 'MetadataCache cache = context.Cache' local; the two cache uses now reference context.Cache directly. Build clean (0 warnings); validation harness reports the same ~640 diffs as the previous fix commit (the local baseline cache was captured against the get-less output and hasn't been refreshed yet) - this commit adds 0 new behavioral diffs, confirmed by sampling: every diff is still just the 'get { ... }' restoration from f21c8d32. Co-Authored-By: Copilot <223556219+Copilot@users.noreply.github.com> --- .../Factories/AbiInterfaceFactory.cs | 5 +- .../Factories/ClassFactory.cs | 7 +- .../Factories/ClassMembersFactory.cs | 2 +- .../Factories/ComponentFactory.cs | 64 ++++++----- .../ConstructorFactory.AttributedTypes.cs | 5 - .../Factories/MetadataAttributeFactory.cs | 15 +-- .../Helpers/AbiTypeHelpers.AbiTypeNames.cs | 2 +- .../Helpers/AbiTypeHelpers.Blittability.cs | 12 +-- .../Helpers/AbiTypeWriter.cs | 100 +++++++++--------- .../Helpers/SignatureGenerator.cs | 14 +-- 10 files changed, 93 insertions(+), 133 deletions(-) diff --git a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs index 5182c7c01..a59fc7f96 100644 --- a/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/AbiInterfaceFactory.cs @@ -294,12 +294,11 @@ public static nint Vtable if (context.Settings.Component) { - MetadataCache cache = context.Cache; - exclusiveToOwner = AbiTypeHelpers.GetExclusiveToType(cache, type); + exclusiveToOwner = AbiTypeHelpers.GetExclusiveToType(context.Cache, type); if (exclusiveToOwner is not null) { - foreach (KeyValuePair kv in AttributedTypes.Get(exclusiveToOwner, cache)) + foreach (KeyValuePair kv in AttributedTypes.Get(exclusiveToOwner, context.Cache)) { if (kv.Value.Type == type && (kv.Value.Statics || kv.Value.Activatable)) { diff --git a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs index 64c589e58..7fc416dc8 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassFactory.cs @@ -247,11 +247,6 @@ public static class {{name}} /// public static void WriteStaticClassMembers(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition type) { - if (context.Cache is null) - { - return; - } - // Per-property accessor state (origin tracking for getter/setter) Dictionary properties = []; @@ -574,7 +569,7 @@ private static void WriteClassCore(IndentedTextWriter writer, ProjectionEmitCont } } } - else if (context.Cache is not null) + else { // In ref mode, if WriteAttributedTypes will not emit any public constructors, // we need a 'private TypeName() { throw null; }' to suppress the C# compiler's diff --git a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs index 9f5f45fe7..7b719432b 100644 --- a/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ClassMembersFactory.cs @@ -91,7 +91,7 @@ internal static void WriteInterfaceTypeNameForCcw(IndentedTextWriter writer, Pro { // If the reference is to a type in the same module, resolve to TypeDefinition so // WriteTypedefName can drop the 'global::.' prefix when the namespace matches. - if (ifaceType is not TypeDefinition && ifaceType is not TypeSpecification && context.Cache is not null) + if (ifaceType is not (TypeDefinition or TypeSpecification)) { TypeDefinition? resolved = ifaceType.TryResolve(context.Cache.RuntimeContext); diff --git a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs index 3d3112d80..b1df5703a 100644 --- a/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/ComponentFactory.cs @@ -57,9 +57,8 @@ public static void WriteFactoryClass(IndentedTextWriter writer, ProjectionEmitCo bool isActivatable = !type.IsStatic && type.HasDefaultConstructor(); // Build the inheritance list: factory interfaces ([Activatable]/[Static]) only. - MetadataCache cache = context.Cache; List factoryInterfaces = []; - foreach (KeyValuePair kv in AttributedTypes.Get(type, cache)) + foreach (KeyValuePair kv in AttributedTypes.Get(type, context.Cache)) { AttributedType info = kv.Value; @@ -107,48 +106,45 @@ public object ActivateInstance() // Emit factory-class members: forwarding methods/properties/events for static factory // interfaces, and constructor wrappers for activatable factory interfaces. - if (cache is not null) + foreach (KeyValuePair kv in AttributedTypes.Get(type, context.Cache)) { - foreach (KeyValuePair kv in AttributedTypes.Get(type, cache)) - { - AttributedType info = kv.Value; + AttributedType info = kv.Value; - if (info.Type is null) - { - continue; - } + if (info.Type is null) + { + continue; + } - if (info.Activatable) + if (info.Activatable) + { + foreach (MethodDefinition method in info.Type.Methods) { - foreach (MethodDefinition method in info.Type.Methods) + if (method.IsConstructor) { - if (method.IsConstructor) - { - continue; - } - - WriteFactoryActivatableMethod(writer, context, method, projectedTypeName); + continue; } + + WriteFactoryActivatableMethod(writer, context, method, projectedTypeName); } - else if (info.Statics) + } + else if (info.Statics) + { + foreach (MethodDefinition method in info.Type.Methods) { - foreach (MethodDefinition method in info.Type.Methods) + if (method.IsConstructor) { - if (method.IsConstructor) - { - continue; - } - - WriteStaticFactoryMethod(writer, context, method, projectedTypeName); - } - foreach (PropertyDefinition prop in info.Type.Properties) - { - WriteStaticFactoryProperty(writer, context, prop, projectedTypeName); - } - foreach (EventDefinition evt in info.Type.Events) - { - WriteStaticFactoryEvent(writer, context, evt, projectedTypeName); + continue; } + + WriteStaticFactoryMethod(writer, context, method, projectedTypeName); + } + foreach (PropertyDefinition prop in info.Type.Properties) + { + WriteStaticFactoryProperty(writer, context, prop, projectedTypeName); + } + foreach (EventDefinition evt in info.Type.Events) + { + WriteStaticFactoryEvent(writer, context, evt, projectedTypeName); } } } diff --git a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs index 4957a3421..1694c6611 100644 --- a/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs +++ b/src/WinRT.Projection.Writer/Factories/ConstructorFactory.AttributedTypes.cs @@ -19,11 +19,6 @@ internal static partial class ConstructorFactory /// public static void WriteAttributedTypes(IndentedTextWriter writer, ProjectionEmitContext context, TypeDefinition classType) { - if (context.Cache is null) - { - return; - } - // Track whether we need to emit the static _objRef_ field (used by // default constructors). Emit it once per class if any [Activatable] factory exists. bool needsClassObjRef = false; diff --git a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs index 6b4e703d8..f09d0bae7 100644 --- a/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs +++ b/src/WinRT.Projection.Writer/Factories/MetadataAttributeFactory.cs @@ -431,7 +431,7 @@ public static void AddDefaultInterfaceEntry(ProjectionEmitContext context, TypeD // branch which knows about authored-type CCW namespacing (ABI.Impl. prefix). ITypeDefOrRef capturedIface = defaultIface; - if (capturedIface is not TypeDefinition && capturedIface is not TypeSpecification && context.Cache is not null) + if (capturedIface is not (TypeDefinition or TypeSpecification)) { TypeDefinition? resolved = capturedIface.TryResolve(context.Cache.RuntimeContext); @@ -471,20 +471,13 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, // Resolve the interface to a TypeDefinition for the [ExclusiveTo] check. TypeDefinition? ifaceDef = impl.Interface as TypeDefinition; - if (ifaceDef is null && context.Cache is not null) - { - ifaceDef = impl.Interface.TryResolve(context.Cache.RuntimeContext); - } + ifaceDef ??= impl.Interface.TryResolve(context.Cache.RuntimeContext); if (ifaceDef is null && impl.Interface is TypeSpecification spec && spec.Signature is GenericInstanceTypeSignature gi) { ifaceDef = gi.GenericType as TypeDefinition; - - if (ifaceDef is null && context.Cache is not null) - { - ifaceDef = gi.GenericType.TryResolve(context.Cache.RuntimeContext); - } + ifaceDef ??= gi.GenericType.TryResolve(context.Cache.RuntimeContext); } if (ifaceDef is null) @@ -498,7 +491,7 @@ public static void AddExclusiveToInterfaceEntries(ProjectionEmitContext context, // Definition branch which knows about authored-type CCW namespacing. ITypeDefOrRef capturedIface = impl.Interface; - if (capturedIface is not TypeDefinition && capturedIface is not TypeSpecification && context.Cache is not null) + if (capturedIface is not (TypeDefinition or TypeSpecification)) { TypeDefinition? resolved = capturedIface.TryResolve(context.Cache.RuntimeContext); diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs index 32500f5e2..c54957464 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.AbiTypeNames.cs @@ -181,7 +181,7 @@ public static string GetAbiPrimitiveType(MetadataCache cache, TypeSignature sig) if (def is not null && def.IsEnum) { - return cache is null ? "int" : GetProjectedEnumName(def); + return GetProjectedEnumName(def); } } diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs index 12ec39873..a78c12a37 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeHelpers.Blittability.cs @@ -184,16 +184,12 @@ internal static bool IsRuntimeClassOrInterface(MetadataCache cache, TypeSignatur // Cross-module typeref: try to resolve via the metadata cache to check category (string ns, string name) = td.Type.Names(); + TypeDefinition? resolved = cache.Find(ns, name); - if (cache is not null) + if (resolved is not null) { - TypeDefinition? resolved = cache.Find(ns, name); - - if (resolved is not null) - { - TypeKind kind = TypeKindResolver.Resolve(resolved); - return kind is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; - } + TypeKind kind = TypeKindResolver.Resolve(resolved); + return kind is TypeKind.Class or TypeKind.Interface or TypeKind.Delegate; } // Unresolved cross-assembly TypeRef (e.g. a referenced winmd we don't have loaded). diff --git a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs index 8484f679c..c2770247a 100644 --- a/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs +++ b/src/WinRT.Projection.Writer/Helpers/AbiTypeWriter.cs @@ -104,76 +104,73 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext // Cross-module typeref: try resolving the type, applying mapped-type translation // for the field/parameter type after resolution. - if (context.Cache is not null) + (string rns, string rname) = r.Type.Names(); + + // Special case: mapped value types that require ABI marshalling. + if (rns == WindowsFoundation && rname == "DateTime") { - (string rns, string rname) = r.Type.Names(); + writer.Write(WellKnownAbiTypeNames.AbiSystemDateTimeOffset); + break; + } - // Special case: mapped value types that require ABI marshalling. - if (rns == WindowsFoundation && rname == "DateTime") - { - writer.Write(WellKnownAbiTypeNames.AbiSystemDateTimeOffset); - break; - } + if (rns == WindowsFoundation && rname == "TimeSpan") + { + writer.Write(WellKnownAbiTypeNames.AbiSystemTimeSpan); + break; + } - if (rns == WindowsFoundation && rname == "TimeSpan") - { - writer.Write(WellKnownAbiTypeNames.AbiSystemTimeSpan); - break; - } + if (rns == WindowsFoundation && rname == HResult) + { + writer.Write(WellKnownAbiTypeNames.AbiSystemException); + break; + } - if (rns == WindowsFoundation && rname == HResult) + // Look up the type by its ORIGINAL (unmapped) name in the cache. + TypeDefinition? rd = context.Cache.Find(rns, rname); + + // If not found, try the mapped name (for cases where the mapping target is in the cache). + if (rd is null) + { + if (MappedTypes.Get(rns, rname) is { } rmapped) { - writer.Write(WellKnownAbiTypeNames.AbiSystemException); - break; + rd = context.Cache.Find(rmapped.MappedNamespace, rmapped.MappedName); } + } - // Look up the type by its ORIGINAL (unmapped) name in the cache. - TypeDefinition? rd = context.Cache.Find(rns, rname); + if (rd is not null) + { + TypeKind kind = TypeKindResolver.Resolve(rd); - // If not found, try the mapped name (for cases where the mapping target is in the cache). - if (rd is null) + if (kind == TypeKind.Enum) { - if (MappedTypes.Get(rns, rname) is { } rmapped) - { - rd = context.Cache.Find(rmapped.MappedNamespace, rmapped.MappedName); - } + // Enums use the projected enum type directly (C# layout == ABI layout). + TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); + break; } - if (rd is not null) + if (kind == TypeKind.Struct) { - TypeKind kind = TypeKindResolver.Resolve(rd); + // Special case: HResult is mapped to System.Exception (a reference type) + // but its ABI representation is the global::ABI.System.Exception struct + // (which wraps the underlying HRESULT int). + (string rdNs, string rdName) = rd.Names(); - if (kind == TypeKind.Enum) + if (rdNs == WindowsFoundation && rdName == HResult) { - // Enums use the projected enum type directly (C# layout == ABI layout). - TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); + writer.Write(WellKnownAbiTypeNames.AbiSystemException); break; } - if (kind == TypeKind.Struct) + if (context.AbiTypeKindResolver.IsBlittableStruct(rd.ToTypeSignature())) { - // Special case: HResult is mapped to System.Exception (a reference type) - // but its ABI representation is the global::ABI.System.Exception struct - // (which wraps the underlying HRESULT int). - (string rdNs, string rdName) = rd.Names(); - - if (rdNs == WindowsFoundation && rdName == HResult) - { - writer.Write(WellKnownAbiTypeNames.AbiSystemException); - break; - } - - if (context.AbiTypeKindResolver.IsBlittableStruct(rd.ToTypeSignature())) - { - TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); - } - else - { - TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.ABI, true); - } - - break; + TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.Projected, true); } + else + { + TypedefNameWriter.WriteTypedefName(writer, context, rd, TypedefNameType.ABI, true); + } + + break; } } @@ -184,7 +181,6 @@ public static void WriteAbiType(IndentedTextWriter writer, ProjectionEmitContext // void* (it's a runtime class/interface/delegate). if (r.IsValueType) { - (string rns, string rname) = r.Type.Names(); writer.Write(GlobalPrefix); if (!string.IsNullOrEmpty(rns)) diff --git a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs index 9ac781df6..a5377e8d0 100644 --- a/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs +++ b/src/WinRT.Projection.Writer/Helpers/SignatureGenerator.cs @@ -98,12 +98,7 @@ private static void WriteSignature(IndentedTextWriter writer, ProjectionEmitCont { // Resolve the reference to a 'TypeDefinition' (cross-module struct field, etc.). (string ns, string name) = r.Type.Names(); - TypeDefinition? resolved = null; - - if (context.Cache is not null) - { - resolved = r.Type.TryResolve(context.Cache.RuntimeContext) ?? context.Cache.Find(ns, name); - } + TypeDefinition? resolved = r.Type.TryResolve(context.Cache.RuntimeContext) ?? context.Cache.Find(ns, name); if (resolved is not null) { @@ -129,12 +124,7 @@ private static void WriteSignature(IndentedTextWriter writer, ProjectionEmitCont // appearing as a struct field). Resolve the generic type to a TypeDefinition // so we can extract its [Guid]; recurse on each type argument. (string ns, string name) = gir.GenericType.Names(); - TypeDefinition? resolved = null; - - if (context.Cache is not null) - { - resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) ?? context.Cache.Find(ns, name); - } + TypeDefinition? resolved = gir.GenericType.TryResolve(context.Cache.RuntimeContext) ?? context.Cache.Find(ns, name); if (resolved is not null) {