Refactor projection writer: interpolated-string + callback emission, classifier resolvers, helper consolidation

nuget/Microsoft.Windows.CsWinRT.targets

@@ -230,12 +230,10 @@ Copyright (C) Microsoft Corporation. All rights reserved.
 
     <PropertyGroup>
       <CsWinRTResponseFile>$(CsWinRTGeneratedFilesDir)cswinrt.rsp</CsWinRTResponseFile>
-      <CsWinRTResponseFilePrivateProjection>$(CsWinRTGeneratedFilesDir)cswinrt_internal.rsp</CsWinRTResponseFilePrivateProjection>
       <!-- %40 is an MSBuild escape code for the @ character; 
        https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2015/msbuild/msbuild-special-characters?view=vs-2015&redirectedfrom=MSDN 
   -->
       <CsWinRTCommand>"$(CsWinRTExe)" %40"$(CsWinRTResponseFile)"</CsWinRTCommand>
-      <CsWinRTCommandPrivateProjection>"$(CsWinRTExe)" %40"$(CsWinRTResponseFilePrivateProjection)"</CsWinRTCommandPrivateProjection>
       <CsWinRTWindowsMetadataInput Condition="'$(CsWinRTWindowsMetadata)' != ''">-input $(CsWinRTWindowsMetadata)</CsWinRTWindowsMetadataInput>
     </PropertyGroup>
 
@@ -249,26 +247,14 @@ Copyright (C) Microsoft Corporation. All rights reserved.
 
     <PropertyGroup>
       <CsWinRTExcludes Condition="'$(CsWinRTExcludes)' == ''">Windows;Microsoft</CsWinRTExcludes>
-      <CsWinRTExcludesPrivate Condition="'$(CsWinRTExcludesPrivate)' == ''">Windows;Microsoft</CsWinRTExcludesPrivate>
     </PropertyGroup>
 
-    <!-- Inputs set by users -->
-    <ItemGroup>
-      <CsWinRTExcludePrivateItems Include="$(CsWinRTExcludesPrivate)"/>
-      <CsWinRTIncludePrivateItems Include="$(CsWinRTIncludesPrivate)"/>
-    </ItemGroup>
-
     <ItemGroup>
       <CsWinRTExcludeItems Include="$(CsWinRTExcludes)"/>
       <CsWinRTIncludeItems Include="$(CsWinRTIncludes)"/>
     </ItemGroup>
 
     <PropertyGroup>
-      <CsWinRTPrivateFilters Condition="'$(CsWinRTPrivateFilters)' == ''">
-@(CsWinRTExcludePrivateItems->'-exclude %(Identity)', '&#x0d;&#x0a;')
-@(CsWinRTIncludePrivateItems->'-include %(Identity)', '&#x0d;&#x0a;')
-      </CsWinRTPrivateFilters>
-
       <CsWinRTFilters Condition="'$(CsWinRTFilters)' == ''">
 @(CsWinRTExcludeItems->'-exclude %(Identity)', '&#x0d;&#x0a;')
 @(CsWinRTIncludeItems->'-include %(Identity)', '&#x0d;&#x0a;')
@@ -280,15 +266,6 @@ Copyright (C) Microsoft Corporation. All rights reserved.
 -include WindowsRuntime.Internal
       </CsWinRTIncludeWinRTInterop>
 
-
-      <CsWinRTPrivateIncludeWinRTInterop Condition="$(CsWinRTPrivateFilters.Contains('-include Windows&#x0d;&#x0a;')) or $(CsWinRTPrivateFilters.Contains('-include Windows&#x0a;'))">
--input $(CsWinRTInteropMetadata)
--include WindowsRuntime.Internal
-      </CsWinRTPrivateIncludeWinRTInterop>
-
-      <CsWinRTInternalProjection Condition="'$(CsWinRTPrivateProjection)' == 'true'">-internal</CsWinRTInternalProjection>
-      <CsWinRTEmbeddedProjection Condition="'$(CsWinRTEmbedded)' == 'true'">-embedded</CsWinRTEmbeddedProjection>
-      <CsWinRTEmbeddedEnums Condition="'$(CsWinRTEmbeddedPublicEnums)' == 'true'">-public_enums</CsWinRTEmbeddedEnums>
       <CsWinRTPublicExclusiveTo Condition="'$(CsWinRTPublicExclusiveToInterfaces)' == 'true'">-public_exclusiveto</CsWinRTPublicExclusiveTo>
       <CsWinRTDynamicallyInterfaceCastableExclusiveTo Condition="'$(CsWinRTDynamicallyInterfaceCastableExclusiveTo)' == 'true'">-idic_exclusiveto</CsWinRTDynamicallyInterfaceCastableExclusiveTo>
       <CsWinRTReferenceProjection Condition="'$(CsWinRTGenerateReferenceProjection)' == 'true'">-reference_projection</CsWinRTReferenceProjection>
@@ -301,23 +278,10 @@ $(CsWinRTWindowsMetadataInput)
 -output "$(CsWinRTGeneratedFilesDir.TrimEnd('\'))"
 $(CsWinRTFilters)
 $(CsWinRTIncludeWinRTInterop)
-$(CsWinRTEmbeddedProjection)
-$(CsWinRTEmbeddedEnums)
 $(CsWinRTPublicExclusiveTo)
 $(CsWinRTDynamicallyInterfaceCastableExclusiveTo)
 $(CsWinRTReferenceProjection)
       </CsWinRTParams>
-
-      <CsWinRTPrivateParams Condition="'$(CsWinRTPrivateParams)' == ''">
-$(CsWinRTCommandVerbosity)
--target $(CsWinRTExeTFM)
-$(CsWinRTWindowsMetadataInput)
--input @(CsWinRTInputs->'"%(FullPath)"', ' ')
--output "$(CsWinRTGeneratedFilesDir.TrimEnd('\'))"
-$(CsWinRTPrivateFilters)
-$(CsWinRTPrivateIncludeWinRTInterop)
-$(CsWinRTInternalProjection)
-      </CsWinRTPrivateParams>
     </PropertyGroup>
 
     <!-- 
@@ -330,7 +294,6 @@ $(CsWinRTInternalProjection)
       <CsWinRTContinueOnError>false</CsWinRTContinueOnError>
       <CsWinRTContinueOnError Condition="'$(DesignTimeBuild)' == 'true' OR '$(BuildingProject)' != 'true'">true</CsWinRTContinueOnError>
       <CsWinRTProjectionExitCode>0</CsWinRTProjectionExitCode>
-      <CsWinRTPrivateProjectionExitCode>0</CsWinRTPrivateProjectionExitCode>
     </PropertyGroup>
 
     <ItemGroup>
@@ -339,64 +302,47 @@ $(CsWinRTInternalProjection)
     <Delete Files="@(CsWinRTFilesToDelete)" />
     <MakeDir Directories="$(CsWinRTGeneratedFilesDir)" />
     <WriteLinesToFile File="$(CsWinRTResponseFile)" Lines="$(CsWinRTParams)" Overwrite="true" />
-    <WriteLinesToFile File="$(CsWinRTResponseFilePrivateProjection)" Lines="$(CsWinRTPrivateParams)" Overwrite="true" />
 
     <!--
       Reconstruct the include/exclude/input lists for the new C# generator from the historical
-      CsWinRTFilters/CsWinRTPrivateFilters multi-line strings. Some projects (e.g. the in-repo
+      CsWinRTFilters multi-line string. Some projects (e.g. the in-repo
       Windows.csproj/Windows.UI.Xaml.csproj/WinAppSDK.csproj) set CsWinRTFilters directly with raw
       cswinrt.exe-style '-include X' / '-exclude Y' directives; others rely on the default item-based
       computation via CsWinRTIncludeItems/CsWinRTExcludeItems. Parsing the final filter strings back
       into items handles both cases uniformly.
     -->
     <ItemGroup>
       <_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 '))" />
     </ItemGroup>
 
     <!--
       Auto-include WindowsRuntime.Internal (and the matching interop metadata WinMD) when the user
-      requested the Windows namespace, mirroring the OLD CsWinRTIncludeWinRTInterop / 
-      CsWinRTPrivateIncludeWinRTInterop behavior.
+      requested the Windows namespace, mirroring the OLD CsWinRTIncludeWinRTInterop behavior.
     -->
     <ItemGroup>
       <_CsWinRTRefHasWindows Include="@(_CsWinRTRefIncludes)" Condition="'%(Identity)' == 'Windows'" />
-      <_CsWinRTRefPrivateHasWindows Include="@(_CsWinRTRefPrivateIncludes)" Condition="'%(Identity)' == 'Windows'" />
     </ItemGroup>
     <ItemGroup Condition="'@(_CsWinRTRefHasWindows)' != ''">
       <_CsWinRTRefIncludes Include="WindowsRuntime.Internal" />
       <_CsWinRTRefInteropInputs Include="$(CsWinRTInteropMetadata)" />
     </ItemGroup>
-    <ItemGroup Condition="'@(_CsWinRTRefPrivateHasWindows)' != ''">
-      <_CsWinRTRefPrivateIncludes Include="WindowsRuntime.Internal" />
-      <_CsWinRTRefPrivateInteropInputs Include="$(CsWinRTInteropMetadata)" />
-    </ItemGroup>
 
     <!--
-      Build the final input-paths list for each pass: user-provided WinMD inputs + Windows SDK
+      Build the final input-paths list: user-provided WinMD inputs + Windows SDK
       metadata token (if any) + the auto-added interop metadata path (if any).
     -->
     <ItemGroup>
       <_CsWinRTRefInputs Include="@(CsWinRTInputs->'%(FullPath)')" />
       <_CsWinRTRefInputs Include="$(CsWinRTWindowsMetadata)" Condition="'$(CsWinRTWindowsMetadata)' != ''" />
       <_CsWinRTRefInputs Include="@(_CsWinRTRefInteropInputs)" />
-
-      <_CsWinRTRefPrivateInputs Include="@(CsWinRTInputs->'%(FullPath)')" />
-      <_CsWinRTRefPrivateInputs Include="$(CsWinRTWindowsMetadata)" Condition="'$(CsWinRTWindowsMetadata)' != ''" />
-      <_CsWinRTRefPrivateInputs Include="@(_CsWinRTRefPrivateInteropInputs)" />
     </ItemGroup>
 
-    <Message Text="cswinrtprojectionrefgen (public projection): @(_CsWinRTRefInputs->Count()) input(s), @(_CsWinRTRefIncludes->Count()) include(s), @(_CsWinRTRefExcludes->Count()) exclude(s)" Importance="$(CsWinRTMessageImportance)" />
+    <Message Text="cswinrtprojectionrefgen: @(_CsWinRTRefInputs->Count()) input(s), @(_CsWinRTRefIncludes->Count()) include(s), @(_CsWinRTRefExcludes->Count()) exclude(s)" Importance="$(CsWinRTMessageImportance)" />
     <RunCsWinRTProjectionRefGenerator
         InputWinMDPaths="@(_CsWinRTRefInputs)"
         OutputDirectory="$(CsWinRTGeneratedFilesDir.TrimEnd('\'))"
@@ -405,8 +351,6 @@ $(CsWinRTInternalProjection)
         ExcludeNamespaces="@(_CsWinRTRefExcludes)"
         Verbose="$(CsWinRTMessageImportance.Equals('high'))"
         Component="$(CsWinRTComponent)"
-        Embedded="$(CsWinRTEmbedded)"
-        PublicEnums="$(CsWinRTEmbeddedPublicEnums)"
         PublicExclusiveTo="$(CsWinRTPublicExclusiveToInterfaces)"
         IdicExclusiveTo="$(CsWinRTDynamicallyInterfaceCastableExclusiveTo)"
         ReferenceProjection="$(CsWinRTGenerateReferenceProjection)"
@@ -416,31 +360,14 @@ $(CsWinRTInternalProjection)
       <Output TaskParameter="ExitCode" PropertyName="CsWinRTProjectionExitCode" />
     </RunCsWinRTProjectionRefGenerator>
 
-    <Message Text="cswinrtprojectionrefgen (private projection): @(_CsWinRTRefPrivateInputs->Count()) input(s), @(_CsWinRTRefPrivateIncludes->Count()) include(s), @(_CsWinRTRefPrivateExcludes->Count()) exclude(s)" Importance="$(CsWinRTMessageImportance)" Condition="'$(CsWinRTPrivateProjection)' == 'true'" />
-    <RunCsWinRTProjectionRefGenerator
-        InputWinMDPaths="@(_CsWinRTRefPrivateInputs)"
-        OutputDirectory="$(CsWinRTGeneratedFilesDir.TrimEnd('\'))"
-        TargetFramework="$(CsWinRTExeTFM)"
-        IncludeNamespaces="@(_CsWinRTRefPrivateIncludes)"
-        ExcludeNamespaces="@(_CsWinRTRefPrivateExcludes)"
-        Verbose="$(CsWinRTMessageImportance.Equals('high'))"
-        Component="$(CsWinRTComponent)"
-        InternalProjection="true"
-        CsWinRTToolsDirectory="$(CsWinRTRefGenEffectiveToolsDirectory)"
-        CsWinRTToolsArchitecture="$(CsWinRTToolsArchitecture)"
-        ContinueOnError="$(CsWinRTContinueOnError)"
-        Condition="'$(CsWinRTPrivateProjection)' == 'true'">
-      <Output TaskParameter="ExitCode" PropertyName="CsWinRTPrivateProjectionExitCode" />
-    </RunCsWinRTProjectionRefGenerator>
-
     <ItemGroup Condition="'$(CsWinRTComponent)' != 'true' and Exists('$(CsWinRTResponseFile)')">
       <UpToDateCheckInput Include="@(CsWinRTInputs)" Set="WinMDs" />
       <UpToDateCheckInput Include="$(CsWinRTGenTasksAssembly)" Set="WinMDs" />
       <UpToDateCheckBuilt Include="$(CsWinRTResponseFile)" Set="WinMDs" />
     </ItemGroup>
 
     <!-- Clean the output file if the target failed to indicate it needs to be rebuild including for design time builds which won't trigger OnError. -->
-    <CallTarget Targets="CsWinRTCleanGenerateProjectionOutputs" Condition="'$(CsWinRTContinueOnError)' == 'true' AND ('$(CsWinRTProjectionExitCode)' != '0' OR '$(CsWinRTPrivateProjectionExitCode)' != '0')" />
+    <CallTarget Targets="CsWinRTCleanGenerateProjectionOutputs" Condition="'$(CsWinRTContinueOnError)' == 'true' AND '$(CsWinRTProjectionExitCode)' != '0'" />
     <OnError ExecuteTargets="CsWinRTCleanGenerateProjectionOutputs" />
   </Target>
 

src/WinRT.Generator.Tasks/RunCsWinRTProjectionRefGenerator.cs

@@ -73,25 +73,6 @@ public sealed class RunCsWinRTProjectionRefGenerator : ToolTask
     /// </summary>
     public bool Component { get; set; }
 
-    /// <summary>
-    /// Gets or sets whether to generate a private (internal) projection. Mirrors the C++ '-internal' arg.
-    /// CsWinRT 3.0 leftover; preserved for OLD-target parity.
-    /// </summary>
-    public bool InternalProjection { get; set; }
-
-    /// <summary>
-    /// Gets or sets whether to generate an embedded projection. Mirrors the C++ '-embedded' arg.
-    /// CsWinRT 3.0 leftover; preserved for OLD-target parity.
-    /// </summary>
-    public bool Embedded { get; set; }
-
-    /// <summary>
-    /// 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.
-    /// </summary>
-    public bool PublicEnums { get; set; }
-
     /// <summary>
     /// Gets or sets whether to make exclusive-to interfaces public in the projection
     /// (default is internal). Mirrors the C++ '-public_exclusiveto' arg.
@@ -258,21 +239,6 @@ protected override string GenerateResponseFileCommands()
             AppendResponseFileCommand(args, "--component", "true");
         }
 
-        if (InternalProjection)
-        {
-            AppendResponseFileCommand(args, "--internal", "true");
-        }
-
-        if (Embedded)
-        {
-            AppendResponseFileCommand(args, "--embedded", "true");
-        }
-
-        if (PublicEnums)
-        {
-            AppendResponseFileCommand(args, "--public-enums", "true");
-        }
-
         if (PublicExclusiveTo)
         {
             AppendResponseFileCommand(args, "--public-exclusive-to", "true");

src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGenerator.cs

@@ -103,9 +103,6 @@ private static ProjectionWriterOptions BuildWriterOptions(ReferenceProjectionGen
             AdditionExclude = args.AdditionExcludeNamespaces,
             Verbose = args.Verbose,
             Component = args.Component,
-            Internal = args.Internal,
-            Embedded = args.Embedded,
-            PublicEnums = args.PublicEnums,
             PublicExclusiveTo = args.PublicExclusiveTo,
             IdicExclusiveTo = args.IdicExclusiveTo,
             ReferenceProjection = args.ReferenceProjection,

src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.Parsing.cs

@@ -87,9 +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)),
-            Embedded = GetOptionalBoolArgument(argsMap, nameof(Embedded)),
-            PublicEnums = GetOptionalBoolArgument(argsMap, nameof(PublicEnums)),
             PublicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(PublicExclusiveTo)),
             IdicExclusiveTo = GetOptionalBoolArgument(argsMap, nameof(IdicExclusiveTo)),
             ReferenceProjection = GetOptionalBoolArgument(argsMap, nameof(ReferenceProjection)),

src/WinRT.Projection.Ref.Generator/Generation/ReferenceProjectionGeneratorArgs.cs

@@ -46,27 +46,6 @@ internal sealed partial class ReferenceProjectionGeneratorArgs
     [CommandLineArgumentName("--component")]
     public bool Component { get; init; }
 
-    /// <summary>
-    /// Gets whether to generate a private (<c>internal</c>) projection.
-    /// CsWinRT 3.0 leftover; preserved for OLD-target parity.
-    /// </summary>
-    [CommandLineArgumentName("--internal")]
-    public bool Internal { get; init; }
-
-    /// <summary>
-    /// Gets whether to generate an embedded projection.
-    /// CsWinRT 3.0 leftover; preserved for OLD-target parity.
-    /// </summary>
-    [CommandLineArgumentName("--embedded")]
-    public bool Embedded { get; init; }
-
-    /// <summary>
-    /// Gets whether to emit enums as public when used with the embedded option.
-    /// CsWinRT 3.0 leftover; preserved for OLD-target parity.
-    /// </summary>
-    [CommandLineArgumentName("--public-enums")]
-    public bool PublicEnums { get; init; }
-
     /// <summary>Gets whether to make exclusive-to interfaces public in the projection.</summary>
     [CommandLineArgumentName("--public-exclusive-to")]
     public bool PublicExclusiveTo { get; init; }