Move C# editorconfig diagnostic support API to CompilationOptions, instead of SyntaxTree

src/Analyzers/Core/Analyzers/RemoveUnnecessarySuppressions/AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs

@@ -99,7 +99,12 @@ public async Task AnalyzeAsync(
             // Bail out if analyzer is suppressed on this file or project.
             // NOTE: Normally, we would not require this check in the analyzer as the analyzer driver has this optimization.
             // However, this is a special analyzer that is directly invoked by the analysis host (IDE), so we do this check here.
-            if (tree.DiagnosticOptions.TryGetValue(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId, out var severity) ||
+            ReportDiagnostic severity;
+            if (
+#if !CODE_STYLE
+                compilationWithAnalyzers.Compilation.Options.SyntaxTreeOptionsProvider != null &&
+                compilationWithAnalyzers.Compilation.Options.SyntaxTreeOptionsProvider.TryGetDiagnosticValue(tree, IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId, out severity) ||
+#endif
                 compilationWithAnalyzers.Compilation.Options.SpecificDiagnosticOptions.TryGetValue(IDEDiagnosticIds.RemoveUnnecessarySuppressionDiagnosticId, out severity))
             {
                 if (severity == ReportDiagnostic.Suppress)

src/Compilers/CSharp/Portable/Binder/Binder.cs

@@ -235,14 +235,17 @@ internal virtual Symbol? ContainingMemberOrLambda
         /// </summary>
         internal bool AreNullableAnnotationsEnabled(SyntaxTree syntaxTree, int position)
         {
-            Syntax.NullableContextState context = ((CSharpSyntaxTree)syntaxTree).GetNullableContextState(position);
+            CSharpSyntaxTree csTree = (CSharpSyntaxTree)syntaxTree;
+            Syntax.NullableContextState context = csTree.GetNullableContextState(position);
 
             return context.AnnotationsState switch
             {
                 Syntax.NullableContextState.State.Enabled => true,
                 Syntax.NullableContextState.State.Disabled => false,
                 Syntax.NullableContextState.State.ExplicitlyRestored => GetGlobalAnnotationState(),
-                Syntax.NullableContextState.State.Unknown => AreNullableAnnotationsGloballyEnabled(),
+                Syntax.NullableContextState.State.Unknown =>
+                    !csTree.IsGeneratedCode(this.Compilation.Options.SyntaxTreeOptionsProvider)
+                    && AreNullableAnnotationsGloballyEnabled(),
                 _ => throw ExceptionUtilities.UnexpectedValue(context.AnnotationsState)
             };
         }
@@ -253,6 +256,12 @@ internal bool AreNullableAnnotationsEnabled(SyntaxToken token)
             return AreNullableAnnotationsEnabled(token.SyntaxTree, token.SpanStart);
         }
 
+        internal bool IsGeneratedCode(SyntaxToken token)
+        {
+            var tree = (CSharpSyntaxTree)token.SyntaxTree!;
+            return tree.IsGeneratedCode(Compilation.Options.SyntaxTreeOptionsProvider);
+        }
+
         internal virtual bool AreNullableAnnotationsGloballyEnabled()
         {
             RoslynDebug.Assert(Next is object);

src/Compilers/CSharp/Portable/Binder/Binder_Constraints.cs

@@ -160,7 +160,11 @@ internal ImmutableArray<TypeParameterConstraintClause> BindTypeParameterConstrai
                             }
                             else
                             {
-                                LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(AreNullableAnnotationsEnabled(questionToken), questionToken.GetLocation(), diagnostics);
+                                LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(
+                                    AreNullableAnnotationsEnabled(questionToken),
+                                    IsGeneratedCode(questionToken),
+                                    questionToken.GetLocation(),
+                                    diagnostics);
                             }
                         }
                         else if (isForOverride || AreNullableAnnotationsEnabled(constraintSyntax.ClassOrStructKeyword))

src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs

@@ -488,16 +488,27 @@ internal NamespaceOrTypeOrAliasSymbolWithAnnotations BindNamespaceOrTypeOrAliasS
             void reportNullableReferenceTypesIfNeeded(SyntaxToken questionToken, TypeWithAnnotations typeArgument = default)
             {
                 bool isNullableEnabled = AreNullableAnnotationsEnabled(questionToken);
+                bool isGeneratedCode = IsGeneratedCode(questionToken);
                 var location = questionToken.GetLocation();
 
                 // Inside a method body or other executable code, we can question IsValueType without causing cycles.
                 if (typeArgument.HasType && !ShouldCheckConstraints)
                 {
-                    LazyMissingNonNullTypesContextDiagnosticInfo.AddAll(isNullableEnabled, typeArgument, location, diagnostics);
+                    LazyMissingNonNullTypesContextDiagnosticInfo.AddAll(
+                        isNullableEnabled,
+                        isGeneratedCode,
+                        typeArgument,
+                        location,
+                        diagnostics);
                 }
                 else
                 {
-                    LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(isNullableEnabled, typeArgument, location, diagnostics);
+                    LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(
+                        isNullableEnabled,
+                        isGeneratedCode,
+                        typeArgument,
+                        location,
+                        diagnostics);
                 }
             }
 

src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs

@@ -81,6 +81,7 @@ public CSharpCompilationOptions(
                    debugPlusMode: false,
                    xmlReferenceResolver: xmlReferenceResolver,
                    sourceReferenceResolver: sourceReferenceResolver,
+                   syntaxTreeOptionsProvider: null,
                    metadataReferenceResolver: metadataReferenceResolver,
                    assemblyIdentityComparer: assemblyIdentityComparer,
                    strongNameProvider: strongNameProvider,
@@ -204,6 +205,7 @@ internal CSharpCompilationOptions(
             bool debugPlusMode,
             XmlReferenceResolver? xmlReferenceResolver,
             SourceReferenceResolver? sourceReferenceResolver,
+            SyntaxTreeOptionsProvider? syntaxTreeOptionsProvider,
             MetadataReferenceResolver? metadataReferenceResolver,
             AssemblyIdentityComparer? assemblyIdentityComparer,
             StrongNameProvider? strongNameProvider,
@@ -216,8 +218,8 @@ internal CSharpCompilationOptions(
                    cryptoKeyContainer, cryptoKeyFile, cryptoPublicKey, delaySign, publicSign, optimizationLevel, checkOverflow,
                    platform, generalDiagnosticOption, warningLevel, specificDiagnosticOptions.ToImmutableDictionaryOrEmpty(),
                    concurrentBuild, deterministic, currentLocalTime, debugPlusMode, xmlReferenceResolver,
-                   sourceReferenceResolver, metadataReferenceResolver, assemblyIdentityComparer,
-                   strongNameProvider, metadataImportOptions, referencesSupersedeLowerVersions)
+                   sourceReferenceResolver, syntaxTreeOptionsProvider, metadataReferenceResolver,
+                   assemblyIdentityComparer, strongNameProvider, metadataImportOptions, referencesSupersedeLowerVersions)
         {
             this.Usings = usings.AsImmutableOrEmpty();
             this.AllowUnsafe = allowUnsafe;
@@ -248,6 +250,7 @@ private CSharpCompilationOptions(CSharpCompilationOptions other) : this(
             debugPlusMode: other.DebugPlusMode,
             xmlReferenceResolver: other.XmlReferenceResolver,
             sourceReferenceResolver: other.SourceReferenceResolver,
+            syntaxTreeOptionsProvider: other.SyntaxTreeOptionsProvider,
             metadataReferenceResolver: other.MetadataReferenceResolver,
             assemblyIdentityComparer: other.AssemblyIdentityComparer,
             strongNameProvider: other.StrongNameProvider,
@@ -573,6 +576,16 @@ internal CSharpCompilationOptions WithReferencesSupersedeLowerVersions(bool valu
             return new CSharpCompilationOptions(this) { SourceReferenceResolver = resolver };
         }
 
+        public new CSharpCompilationOptions WithSyntaxTreeOptionsProvider(SyntaxTreeOptionsProvider? provider)
+        {
+            if (ReferenceEquals(provider, this.SyntaxTreeOptionsProvider))
+            {
+                return this;
+            }
+
+            return new CSharpCompilationOptions(this) { SyntaxTreeOptionsProvider = provider };
+        }
+
         public new CSharpCompilationOptions WithMetadataReferenceResolver(MetadataReferenceResolver? resolver)
         {
             if (ReferenceEquals(resolver, this.MetadataReferenceResolver))
@@ -625,6 +638,9 @@ protected override CompilationOptions CommonWithXmlReferenceResolver(XmlReferenc
         protected override CompilationOptions CommonWithSourceReferenceResolver(SourceReferenceResolver? resolver) =>
             WithSourceReferenceResolver(resolver);
 
+        protected override CompilationOptions CommonWithSyntaxTreeOptionsProvider(SyntaxTreeOptionsProvider? provider)
+            => WithSyntaxTreeOptionsProvider(provider);
+
         protected override CompilationOptions CommonWithMetadataReferenceResolver(MetadataReferenceResolver? resolver) =>
             WithMetadataReferenceResolver(resolver);
 
@@ -739,9 +755,15 @@ public override int GetHashCode()
                    Hash.Combine(TopLevelBinderFlags.GetHashCode(), this.NullableContextOptions.GetHashCode()))));
         }
 
-        internal override Diagnostic FilterDiagnostic(Diagnostic diagnostic)
+        internal override Diagnostic? FilterDiagnostic(Diagnostic diagnostic)
         {
-            return CSharpDiagnosticFilter.Filter(diagnostic, WarningLevel, NullableContextOptions, GeneralDiagnosticOption, SpecificDiagnosticOptions);
+            return CSharpDiagnosticFilter.Filter(
+                diagnostic,
+                WarningLevel,
+                NullableContextOptions,
+                GeneralDiagnosticOption,
+                SpecificDiagnosticOptions,
+                SyntaxTreeOptionsProvider);
         }
 
         protected override CompilationOptions CommonWithModuleName(string? moduleName)
@@ -901,6 +923,7 @@ public CSharpCompilationOptions(
                    debugPlusMode: false,
                    xmlReferenceResolver: xmlReferenceResolver,
                    sourceReferenceResolver: sourceReferenceResolver,
+                   syntaxTreeOptionsProvider: null,
                    metadataReferenceResolver: metadataReferenceResolver,
                    assemblyIdentityComparer: assemblyIdentityComparer,
                    strongNameProvider: strongNameProvider,

src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable enable
+
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -36,7 +38,7 @@ protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, st
         public override DiagnosticFormatter DiagnosticFormatter { get { return _diagnosticFormatter; } }
         protected internal new CSharpCommandLineArguments Arguments { get { return (CSharpCommandLineArguments)base.Arguments; } }
 
-        public override Compilation CreateCompilation(
+        public override Compilation? CreateCompilation(
             TextWriter consoleOutput,
             TouchedFileLogger touchedFilesLogger,
             ErrorLogger errorLogger,
@@ -51,7 +53,7 @@ public override Compilation CreateCompilation(
             bool hadErrors = false;
 
             var sourceFiles = Arguments.SourceFiles;
-            var trees = new SyntaxTree[sourceFiles.Length];
+            var trees = new SyntaxTree?[sourceFiles.Length];
             var normalizedFilePaths = new string[sourceFiles.Length];
             var diagnosticBag = DiagnosticBag.GetInstance();
 
@@ -65,9 +67,6 @@ public override Compilation CreateCompilation(
                         trees[i] = ParseFile(
                             parseOptions,
                             scriptParseOptions,
-                            analyzerConfigOptions.IsDefault
-                                ? (AnalyzerConfigOptionsResult?)null
-                                : analyzerConfigOptions[i],
                             ref hadErrors,
                             sourceFiles[i],
                             diagnosticBag,
@@ -87,9 +86,6 @@ public override Compilation CreateCompilation(
                     trees[i] = ParseFile(
                         parseOptions,
                         scriptParseOptions,
-                        analyzerConfigOptions.IsDefault
-                            ? (AnalyzerConfigOptionsResult?)null
-                            : analyzerConfigOptions[i],
                         ref hadErrors,
                         sourceFiles[i],
                         diagnosticBag,
@@ -163,23 +159,24 @@ public override Compilation CreateCompilation(
             }
 
             var loggingFileSystem = new LoggingStrongNameFileSystem(touchedFilesLogger, _tempDirectory);
+            var optionsProvider = new CompilerSyntaxTreeOptionsProvider(trees, analyzerConfigOptions);
 
             return CSharpCompilation.Create(
                 Arguments.CompilationName,
                 trees.WhereNotNull(),
                 resolvedReferences,
-                Arguments.CompilationOptions.
-                    WithMetadataReferenceResolver(referenceDirectiveResolver).
-                    WithAssemblyIdentityComparer(assemblyIdentityComparer).
-                    WithXmlReferenceResolver(xmlFileResolver).
-                    WithStrongNameProvider(Arguments.GetStrongNameProvider(loggingFileSystem)).
-                    WithSourceReferenceResolver(sourceFileResolver));
+                Arguments.CompilationOptions
+                    .WithMetadataReferenceResolver(referenceDirectiveResolver)
+                    .WithAssemblyIdentityComparer(assemblyIdentityComparer)
+                    .WithXmlReferenceResolver(xmlFileResolver)
+                    .WithStrongNameProvider(Arguments.GetStrongNameProvider(loggingFileSystem))
+                    .WithSourceReferenceResolver(sourceFileResolver)
+                    .WithSyntaxTreeOptionsProvider(optionsProvider));
         }
 
-        private SyntaxTree ParseFile(
+        private SyntaxTree? ParseFile(
             CSharpParseOptions parseOptions,
             CSharpParseOptions scriptParseOptions,
-            AnalyzerConfigOptionsResult? analyzerConfigOptionsResult,
             ref bool addedDiagnostics,
             CommandLineSourceFile file,
             DiagnosticBag diagnostics,
@@ -201,36 +198,20 @@ private SyntaxTree ParseFile(
             else
             {
                 Debug.Assert(fileDiagnostics.Count == 0);
-                return ParseFile(parseOptions, scriptParseOptions, content, file, analyzerConfigOptionsResult);
+                return ParseFile(parseOptions, scriptParseOptions, content, file);
             }
         }
 
         private static SyntaxTree ParseFile(
             CSharpParseOptions parseOptions,
             CSharpParseOptions scriptParseOptions,
             SourceText content,
-            CommandLineSourceFile file,
-            AnalyzerConfigOptionsResult? analyzerConfigOptionsResult)
+            CommandLineSourceFile file)
         {
-            ImmutableDictionary<string, ReportDiagnostic> diagnosticOptions;
-            bool? isUserConfiguredGeneratedCode;
-            if (analyzerConfigOptionsResult.HasValue)
-            {
-                diagnosticOptions = analyzerConfigOptionsResult.Value.TreeOptions;
-                isUserConfiguredGeneratedCode = GeneratedCodeUtilities.GetIsGeneratedCodeFromOptions(analyzerConfigOptionsResult.Value.AnalyzerOptions);
-            }
-            else
-            {
-                diagnosticOptions = null;
-                isUserConfiguredGeneratedCode = null;
-            }
-
             var tree = SyntaxFactory.ParseSyntaxTree(
                 content,
                 file.IsScript ? scriptParseOptions : parseOptions,
-                file.Path,
-                diagnosticOptions,
-                isUserConfiguredGeneratedCode);
+                file.Path);
 
             // prepopulate line tables.
             // we will need line tables anyways and it is better to not wait until we are in emit
@@ -264,26 +245,23 @@ protected override string GetOutputFileName(Compilation compilation, Cancellatio
 
                 var comp = (CSharpCompilation)compilation;
 
-                Symbol entryPoint = comp.ScriptClass;
-                if ((object)entryPoint == null)
+                Symbol? entryPoint = comp.ScriptClass;
+                if (entryPoint is null)
                 {
                     var method = comp.GetEntryPoint(cancellationToken);
-                    if ((object)method != null)
+                    if (method is object)
                     {
                         entryPoint = method.PartialImplementationPart ?? method;
                     }
+                    else
+                    {
+                        // no entrypoint found - an error will be reported and the compilation won't be emitted
+                        return "error";
+                    }
                 }
 
-                if ((object)entryPoint != null)
-                {
-                    string entryPointFileName = PathUtilities.GetFileName(entryPoint.Locations.First().SourceTree.FilePath);
-                    return Path.ChangeExtension(entryPointFileName, ".exe");
-                }
-                else
-                {
-                    // no entrypoint found - an error will be reported and the compilation won't be emitted
-                    return "error";
-                }
+                string entryPointFileName = PathUtilities.GetFileName(entryPoint.Locations.First().SourceTree!.FilePath);
+                return Path.ChangeExtension(entryPointFileName, ".exe");
             }
             else
             {
@@ -312,7 +290,7 @@ public override void PrintLangVersions(TextWriter consoleOutput)
             consoleOutput.WriteLine(ErrorFacts.GetMessage(MessageID.IDS_LangVersions, Culture));
             var defaultVersion = LanguageVersion.Default.MapSpecifiedToEffectiveVersion();
             var latestVersion = LanguageVersion.Latest.MapSpecifiedToEffectiveVersion();
-            foreach (LanguageVersion v in Enum.GetValues(typeof(LanguageVersion)))
+            foreach (var v in (LanguageVersion[])Enum.GetValues(typeof(LanguageVersion)))
             {
                 if (v == defaultVersion)
                 {
@@ -376,13 +354,13 @@ protected override void ResolveEmbeddedFilesFromExternalSourceDirectives(
             foreach (LineDirectiveTriviaSyntax directive in tree.GetRoot().GetDirectives(
                 d => d.IsActive && !d.HasErrors && d.Kind() == SyntaxKind.LineDirectiveTrivia))
             {
-                string path = (string)directive.File.Value;
+                var path = (string?)directive.File.Value;
                 if (path == null)
                 {
                     continue;
                 }
 
-                string resolvedPath = resolver.ResolveReference(path, tree.FilePath);
+                string? resolvedPath = resolver.ResolveReference(path, tree.FilePath);
                 if (resolvedPath == null)
                 {
                     diagnostics.Add(