Add support for required keyword

src/Microsoft.Cci.Extensions/Extensions/CSharp/CSharpCciExtensions.cs

@@ -805,6 +805,11 @@ public static bool HasNativeIntegerAttribute(this IEnumerable<ICustomAttribute>
  return attributes.HasAttributeOfType("System.Runtime.CompilerServices.NativeIntegerAttribute");
  }
 
+ public static bool HasRequiredMemberAttribute(this IEnumerable<ICustomAttribute> attributes)
+ {
+ return attributes.HasAttributeOfType("System.Runtime.CompilerServices.RequiredMemberAttribute");
+ }
+
  public static string[] GetValueTupleNames(this IEnumerable<ICustomAttribute> attributes)
  {
  string[] names = null;

src/Microsoft.Cci.Extensions/Writers/CSharp/CSDeclarationWriter.Attributes.cs

@@ -376,15 +376,17 @@ private static bool ExcludeSpecialAttribute(ICustomAttribute c)
 
  switch (typeName)
  {
- case "System.Runtime.CompilerServices.FixedBufferAttribute": return true;
  case "System.ParamArrayAttribute": return true;
- case "System.Reflection.DefaultMemberAttribute": return true;
- case "System.Reflection.AssemblyKeyFileAttribute": return true;
  case "System.Reflection.AssemblyDelaySignAttribute": return true;
- case "System.Runtime.CompilerServices.ExtensionAttribute": return true;
+ case "System.Reflection.AssemblyKeyFileAttribute": return true;
+ case "System.Reflection.DefaultMemberAttribute": return true;
+ case "System.Runtime.CompilerServices.CompilerFeatureRequiredAttribute": return true;
  case "System.Runtime.CompilerServices.DynamicAttribute": return true;
+ case "System.Runtime.CompilerServices.ExtensionAttribute": return true;
+ case "System.Runtime.CompilerServices.FixedBufferAttribute": return true;
  case "System.Runtime.CompilerServices.IsByRefLikeAttribute": return true;
  case "System.Runtime.CompilerServices.IsReadOnlyAttribute": return true;
+ case "System.Runtime.CompilerServices.RequiredMemberAttribute": return true;
  case "System.Runtime.CompilerServices.TupleElementNamesAttribute": return true;
  case "System.ObsoleteAttribute":
  {
@@ -393,7 +395,8 @@ private static bool ExcludeSpecialAttribute(ICustomAttribute c)
  if (arg?.Value is string)
  {
  string argValue = (string)arg.Value;
- if (argValue == "Types with embedded references are not supported in this version of your compiler.")
+ if (argValue is "Types with embedded references are not supported in this version of your compiler."
+ or "Constructors of types with required members are not supported in this version of your compiler.")
  {
  return true;
  }

src/Microsoft.Cci.Extensions/Writers/CSharp/CSDeclarationWriter.Fields.cs

@@ -30,6 +30,11 @@ private void WriteFieldDefinition(IFieldDefinition field)
  WriteVisibility(field.Visibility);
  WriteCustomModifiers(field.CustomModifiers);
 
+ if (field.Attributes.HasRequiredMemberAttribute())
+ {
+ WriteKeyword("required");
+ }
+
  if (field.Type.IsUnsafeType())
  WriteKeyword("unsafe");
 

src/Microsoft.Cci.Extensions/Writers/CSharp/CSDeclarationWriter.Properties.cs

@@ -74,6 +74,11 @@ private void WritePropertyDefinition(IPropertyDefinition property)
  WriteVisibility(property.Visibility);
  }
 
+ if (property.Attributes.HasRequiredMemberAttribute())
+ {
+ WriteKeyword("required");
+ }
+
  // Getter and Setter modifiers should be the same
  WriteMethodModifiers(accessor);
 

src/Microsoft.DotNet.GenFacades/GenPartialFacadeSource.cs

@@ -9,7 +9,7 @@
 
 namespace Microsoft.DotNet.GenFacades
 {
- public class GenPartialFacadeSource : BuildTask
+ public class GenPartialFacadeSource : RoslynBuildTask
  {
  [Required]
  public ITaskItem[] ReferencePaths { get; set; }
@@ -21,6 +21,8 @@ public class GenPartialFacadeSource : BuildTask
 
  public string DefineConstants { get; set; }
 
+ public string LangVersion { get; set; }
+
  public bool IgnoreMissingTypes { get; set; }
 
  public string[] IgnoreMissingTypesList { get; set; }
@@ -32,7 +34,7 @@ public class GenPartialFacadeSource : BuildTask
  [Required]
  public string OutputSourcePath { get; set; }
 
- public override bool Execute()
+ public override bool ExecuteCore()
  {
  bool result = true;
  try
@@ -42,6 +44,7 @@ public override bool Execute()
  ReferenceAssembly,
  CompileFiles?.Select(item => item.ItemSpec).ToArray(),
  DefineConstants,
+ LangVersion,
  OutputSourcePath,
  Log,
  IgnoreMissingTypes,

src/Microsoft.DotNet.GenFacades/GenPartialFacadeSourceGenerator.cs

@@ -21,6 +21,7 @@ public static bool Execute(
  string contractAssembly,
  string[] compileFiles,
  string defineConstants,
+ string langVersion,
  string outputSourcePath,
  ILog logger,
  bool ignoreMissingTypes = false,
@@ -52,7 +53,7 @@ public static bool Execute(
  referenceTypes = referenceTypes.Where(type => !OmitTypes.Contains(type));
 
  var sourceGenerator = new SourceGenerator(referenceTypes, seedTypes, seedTypePreferences, outputSourcePath, ignoreMissingTypesList, logger);
- return sourceGenerator.GenerateSource(compileFiles, ParseDefineConstants(defineConstants), ignoreMissingTypes);
+ return sourceGenerator.GenerateSource(compileFiles, ParseDefineConstants(defineConstants), langVersion, ignoreMissingTypes);
  }
 
  private static IEnumerable<string> ParseDefineConstants(string defineConstants)

src/Microsoft.DotNet.GenFacades/Microsoft.DotNet.GenFacades.csproj

@@ -11,7 +11,7 @@
  <ItemGroup>
  <PackageReference Include="Microsoft.Build" Version="$(MicrosoftBuildVersion)" Publish="false" />
  <PackageReference Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCoreVersion)" Publish="false" />
- <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MsbuildTaskMicrosoftCodeAnalysisCSharpVersion)" ExcludeAssets="analyzers" />
+ <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MsbuildTaskMicrosoftCodeAnalysisCSharpVersion)" ExcludeAssets="analyzers" Publish="false" />
  </ItemGroup>
 
  <!-- When building offline we need to bump the version of System.Reflection.Metadata that CodeAnalysis package depends on to match what the source build tarball expects. -->

src/Microsoft.DotNet.GenFacades/NotSupportedAssemblyGenerator.cs

@@ -16,17 +16,19 @@ namespace Microsoft.DotNet.GenFacades
  /// <summary>
  /// The class generates an NotSupportedAssembly from the reference sources.
  /// </summary>
- public class NotSupportedAssemblyGenerator : BuildTask
+ public class NotSupportedAssemblyGenerator : RoslynBuildTask
  {
  [Required]
  public ITaskItem[] SourceFiles { get; set; }
 
  [Required]
  public string Message { get; set; }
 
+ public string LangVersion { get; set; }
+
  public string ApiExclusionListPath { get; set; }
 
- public override bool Execute()
+ public override bool ExecuteCore()
  {
  if (SourceFiles == null || SourceFiles.Length == 0)
  {
@@ -68,7 +70,13 @@ private void GenerateNotSupportedAssemblyForSourceFile(string sourceFile, string
 
  try
  {
- syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(sourceFile));
+ LanguageVersion languageVersion = LanguageVersion.Default;
+ if (!String.IsNullOrEmpty(LangVersion) && !LanguageVersionFacts.TryParse(LangVersion, out languageVersion))
+ {
+ Log.LogError($"Invalid LangVersion value '{LangVersion}'");
+ return;
+ }
+ syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(sourceFile), new CSharpParseOptions(languageVersion));
  }
  catch(Exception ex)
  {

src/Microsoft.DotNet.GenFacades/RoslynBuildTask.cs

@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+using System;
+using System.IO;
+using System.Reflection;
+#if NETCOREAPP
+using System.Runtime.Loader;
+#endif
+
+namespace Microsoft.DotNet.Build.Tasks
+{
+ public abstract partial class RoslynBuildTask : BuildTask
+ {
+ [Required]
+ public string RoslynAssembliesPath { get; set; }
+
+ public override bool Execute()
+ {
+#if NETCOREAPP
+ AssemblyLoadContext currentContext = AssemblyLoadContext.GetLoadContext(Assembly.GetExecutingAssembly())!;
+ currentContext.Resolving += ResolverForRoslyn;
+#else
+ AppDomain.CurrentDomain.AssemblyResolve += ResolverForRoslyn;
+#endif
+ try
+ {
+ return ExecuteCore();
+ }
+ finally
+ {
+#if NETCOREAPP
+ currentContext.Resolving -= ResolverForRoslyn;
+#else
+ AppDomain.CurrentDomain.AssemblyResolve -= ResolverForRoslyn;
+#endif
+ }
+ }
+
+ public abstract bool ExecuteCore();
+
+#if NETCOREAPP
+ private Assembly ResolverForRoslyn(AssemblyLoadContext context, AssemblyName assemblyName)
+ {
+ return LoadRoslyn(assemblyName, path => context.LoadFromAssemblyPath(path));
+ }
+#else
+ private Assembly ResolverForRoslyn(object sender, ResolveEventArgs args)
+ {
+ AssemblyName name = new(args.Name);
+ return LoadRoslyn(name, path => Assembly.LoadFrom(path));
+ }
+#endif
+
+ private Assembly LoadRoslyn(AssemblyName name, Func<string, Assembly> loadFromPath)
+ {
+ const string codeAnalysisName = "Microsoft.CodeAnalysis";
+ const string codeAnalysisCsharpName = "Microsoft.CodeAnalysis.CSharp";
+ if (name.Name == codeAnalysisName || name.Name == codeAnalysisCsharpName)
+ {
+ Assembly asm = loadFromPath(Path.Combine(RoslynAssembliesPath!, $"{name.Name}.dll"));
+ Version resolvedVersion = asm.GetName().Version;
+ if (resolvedVersion < name.Version)
+ {
+ throw new Exception($"The minimum version required of Roslyn is '{name.Version}' and you are using '{resolvedVersion}' version of the Roslyn. You can update the sdk to get the latest version.");
+ }
+
+ // Being extra defensive but we want to avoid that we accidentally load two different versions of either
+ // of the roslyn assemblies from a different location, so let's load them both on the first request.
+ Assembly _ = name.Name == codeAnalysisName ?
+ loadFromPath(Path.Combine(RoslynAssembliesPath!, $"{codeAnalysisCsharpName}.dll")) :
+ loadFromPath(Path.Combine(RoslynAssembliesPath!, $"{codeAnalysisName}.dll"));
+
+ return asm;
+ }
+
+ return null;
+ }
+ }
+}

src/Microsoft.DotNet.GenFacades/SourceGenerator.cs

@@ -41,6 +41,7 @@ ILog logger
  public bool GenerateSource(
  IEnumerable<string> compileFiles,
  IEnumerable<string> constants,
+ string langVersion,
  bool ignoreMissingTypes)
  {
  List<string> externAliases = new List<string>();
@@ -51,7 +52,7 @@ public bool GenerateSource(
 
  bool result = true;
 
- HashSet<string> existingTypes = compileFiles != null ? TypeParser.GetAllPublicTypes(compileFiles, constants) : null;
+ HashSet<string> existingTypes = compileFiles != null ? TypeParser.GetAllPublicTypes(compileFiles, constants, langVersion) : null;
  IEnumerable<string> typesToForward = compileFiles == null ? _referenceTypes : _referenceTypes.Where(id => !existingTypes.Contains(id));
 
  foreach (string type in typesToForward.OrderBy(s => s))

src/Microsoft.DotNet.GenFacades/TypeParser.cs

@@ -4,6 +4,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -12,10 +13,17 @@ namespace Microsoft.DotNet.GenFacades
 {
  internal class TypeParser
  {
- public static HashSet<string> GetAllPublicTypes(IEnumerable<string> files, IEnumerable<string> constants)
+ public static HashSet<string> GetAllPublicTypes(IEnumerable<string> files, IEnumerable<string> constants, string langVersion)
  {
  HashSet<string> types = new HashSet<string>();
- var syntaxTreeCollection = GetSourceTrees(files, constants);
+
+ LanguageVersion languageVersion = LanguageVersion.Default;
+ if (!string.IsNullOrEmpty(langVersion) && !LanguageVersionFacts.TryParse(langVersion, out languageVersion))
+ {
+ throw new ArgumentException($"Invalid C# language version value '{langVersion}'", nameof(langVersion));
+ }
+
+ var syntaxTreeCollection = GetSourceTrees(files, constants, languageVersion);
 
  foreach (var tree in syntaxTreeCollection)
  {
@@ -122,9 +130,9 @@ private static string GetNamespaceName(NamespaceDeclarationSyntax namespaceSynta
  return namespaceSyntax.Name.ToFullString().Trim();
  }
 
- private static IEnumerable<SyntaxTree> GetSourceTrees(IEnumerable<string> sourceFiles, IEnumerable<string> constants)
+ private static IEnumerable<SyntaxTree> GetSourceTrees(IEnumerable<string> sourceFiles, IEnumerable<string> constants, LanguageVersion languageVersion)
  {
- CSharpParseOptions options = new CSharpParseOptions().WithPreprocessorSymbols(constants);
+ CSharpParseOptions options = new CSharpParseOptions(languageVersion: languageVersion, preprocessorSymbols: constants);
  List<SyntaxTree> result = new List<SyntaxTree>();
  foreach (string sourceFile in sourceFiles)
  {

src/Microsoft.DotNet.GenFacades/build/Microsoft.DotNet.GenFacades.targets

@@ -6,6 +6,17 @@
  <GenFacadesTargetAssemblyPath Condition="'$(MSBuildRuntimeType)' != 'Core'">$(MSBuildThisFileDirectory)..\tools\net472\Microsoft.DotNet.GenFacades.dll</GenFacadesTargetAssemblyPath>
  </PropertyGroup>
 
+ <Target Name="_GetRoslynAssembliesPath">
+ <PropertyGroup Condition="'$(RoslynAssembliesPath)' == ''">
+ <RoslynAssembliesPath>$(RoslynTargetsPath)</RoslynAssembliesPath>
+ <_packageReferenceList>@(PackageReference)</_packageReferenceList>
+ <!-- CSharpCoreTargetsPath and VisualBasicCoreTargetsPath point to the same location, Microsoft.CodeAnalysis.CSharp and Microsoft.CodeAnalysis.VisualBasic
+ are on the same directory as Microsoft.CodeAnalysis. So there is no need to distinguish between csproj or vbproj. -->
+ <RoslynAssembliesPath Condition="$(_packageReferenceList.Contains('Microsoft.Net.Compilers.Toolset'))">$([System.IO.Path]::GetDirectoryName($(CSharpCoreTargetsPath)))</RoslynAssembliesPath>
+ <RoslynAssembliesPath Condition="'$(MSBuildRuntimeType)' == 'Core'">$([System.IO.Path]::Combine('$(RoslynAssembliesPath)', bincore))</RoslynAssembliesPath>
+ </PropertyGroup>
+ </Target>
+
  <Import Project="Microsoft.DotNet.GenPartialFacadeSource.targets" Condition="'$(IsPartialFacadeAssembly)' == 'true'" />
  <Import Project="Microsoft.DotNet.GenFacadesNotSupported.targets" Condition="'$(GeneratePlatformNotSupportedAssembly)' == 'true' or
  '$(GeneratePlatformNotSupportedAssemblyMessage)' != ''" />

src/Microsoft.DotNet.GenFacades/build/Microsoft.DotNet.GenFacadesNotSupported.targets

@@ -47,16 +47,18 @@
  </Target>
 
  <Target Name="AddGenFacadeNotSupportedCompileItem"
- DependsOnTargets="_GetGenFacadeNotSupportedCompileInputs"
+ DependsOnTargets="_GetGenFacadeNotSupportedCompileInputs;_GetRoslynAssembliesPath"
  AfterTargets="ResolveProjectReferences"
  Condition="'$(GeneratePlatformNotSupportedAssemblyMessage)' != ''"
  Inputs="@(GenFacadeNotSupportedCompileInput)"
  Outputs="@(GenFacadeNotSupportedCompileInput->'%(OutputPath)')" >
 
  <NotSupportedAssemblyGenerator
  SourceFiles="@(GenFacadeNotSupportedCompileInput)"
+ LangVersion="$(LangVersion)"
  Message="$(GeneratePlatformNotSupportedAssemblyMessage)"
- ApiExclusionListPath="$(ApiExclusionListPath)" />
+ ApiExclusionListPath="$(ApiExclusionListPath)"
+ RoslynAssembliesPath="$(RoslynAssembliesPath)" />
 
  <ItemGroup>
  <Compile Include="@(GenFacadeNotSupportedCompileInput->'%(OutputPath)')" />

src/Microsoft.DotNet.GenFacades/build/Microsoft.DotNet.GenPartialFacadeSource.targets

@@ -8,7 +8,7 @@
  <GenFacadesReferencePathItemName Condition="'$(GenFacadesReferencePathItemName)' == ''">ReferencePath</GenFacadesReferencePathItemName>
  <!-- Tell ResolveMatchingContract to run and resolve contract to project reference -->
  <ResolveMatchingContract>true</ResolveMatchingContract>
- <GeneratePartialFacadeSourceDependsOn>$(GeneratePartialFacadeSourceDependsOn);ResolveMatchingContract</GeneratePartialFacadeSourceDependsOn>
+ <GeneratePartialFacadeSourceDependsOn>$(GeneratePartialFacadeSourceDependsOn);ResolveMatchingContract;_GetRoslynAssembliesPath</GeneratePartialFacadeSourceDependsOn>
  <CoreCompileDependsOn Condition="'$(DesignTimeBuild)' != 'true'">$(CoreCompileDependsOn);GeneratePartialFacadeSource</CoreCompileDependsOn>
  <!-- Support zero version seeds by rewriting the output of the compiler. -->
  <TargetsTriggeredByCompilation Condition="'$(DesignTimeBuild)' != 'true' and '$(GenFacadesForceZeroVersionSeeds)' == 'true'">
@@ -30,11 +30,13 @@
  ReferenceAssembly="$(ReferenceAssembly)"
  CompileFiles="@(Compile)"
  DefineConstants="$(DefineConstants)"
+ LangVersion="$(LangVersion)"
  IgnoreMissingTypes="$(GenFacadesIgnoreMissingTypes)"
  IgnoreMissingTypesList="@(GenFacadesIgnoreMissingType)"
  OmitTypes="@(GenFacadesOmitType)"
  OutputSourcePath="$(OutputSourcePath)"
- SeedTypePreferences="@(SeedTypePreference)" />
+ SeedTypePreferences="@(SeedTypePreference)"
+ RoslynAssembliesPath="$(RoslynAssembliesPath)" />
 
  <ItemGroup Condition="Exists('$(OutputSourcePath)')">
  <Compile Include="$(OutputSourcePath)" />