Improve lightup support for BaseNamespaceDeclarationSyntax

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs

@@ -986,6 +986,65 @@ private void GenerateSyntaxWrapperHelper(in SourceProductionContext context, Imm
                     continue;
                 }
 
+                if (node.Name == nameof(BaseNamespaceDeclarationSyntax))
+                {
+                    // Prior to C# 10, NamespaceDeclarationSyntax was the base type for all namespace declarations.
+                    // If the BaseNamespaceDeclarationSyntax type isn't found at runtime, we fall back
+                    // to using this type instead.
+                    //
+                    // var baseNamespaceDeclarationSyntaxType = csharpCodeAnalysisAssembly.GetType(BaseNamespaceDeclarationSyntaxWrapper.WrappedTypeName)
+                    //     ?? csharpCodeAnalysisAssembly.GetType(BaseNamespaceDeclarationSyntaxWrapper.WrappedTypeName);
+                    LocalDeclarationStatementSyntax localStatement =
+                        SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
+                            type: SyntaxFactory.IdentifierName("var"),
+                            variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(
+                                identifier: SyntaxFactory.Identifier("baseNamespaceDeclarationSyntaxType"),
+                                argumentList: null,
+                                initializer: SyntaxFactory.EqualsValueClause(
+                                    SyntaxFactory.BinaryExpression(
+                                        SyntaxKind.CoalesceExpression,
+                                        left: SyntaxFactory.InvocationExpression(
+                                            expression: SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"),
+                                                name: SyntaxFactory.IdentifierName("GetType")),
+                                            argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                                                SyntaxFactory.MemberAccessExpression(
+                                                    SyntaxKind.SimpleMemberAccessExpression,
+                                                    expression: SyntaxFactory.IdentifierName(node.WrapperName),
+                                                    name: SyntaxFactory.IdentifierName("WrappedTypeName")))))),
+                                        right: SyntaxFactory.InvocationExpression(
+                                            expression: SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"),
+                                                name: SyntaxFactory.IdentifierName("GetType")),
+                                            argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                                                SyntaxFactory.MemberAccessExpression(
+                                                    SyntaxKind.SimpleMemberAccessExpression,
+                                                    expression: SyntaxFactory.IdentifierName(node.WrapperName),
+                                                    name: SyntaxFactory.IdentifierName("FallbackWrappedTypeName"))))))))))));
+
+                    // This is the first line of the statements that initialize 'builder', so start it with a blank line
+                    staticCtorStatements = staticCtorStatements.Add(localStatement.WithLeadingBlankLine());
+
+                    // builder.Add(typeof(BaseNamespaceDeclarationSyntaxWrapper), baseNamespaceDeclarationSyntaxType);
+                    staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement(
+                        SyntaxFactory.InvocationExpression(
+                            expression: SyntaxFactory.MemberAccessExpression(
+                                SyntaxKind.SimpleMemberAccessExpression,
+                                expression: SyntaxFactory.IdentifierName("builder"),
+                                name: SyntaxFactory.IdentifierName("Add")),
+                            argumentList: SyntaxFactory.ArgumentList(
+                                SyntaxFactory.SeparatedList(
+                                    new[]
+                                    {
+                                        SyntaxFactory.Argument(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName(node.WrapperName))),
+                                        SyntaxFactory.Argument(SyntaxFactory.IdentifierName("baseNamespaceDeclarationSyntaxType")),
+                                    })))));
+
+                    continue;
+                }
+
                 // builder.Add(typeof(ConstantPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ConstantPatternSyntaxWrapper.WrappedTypeName));
                 staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement(
                     SyntaxFactory.InvocationExpression(

StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SyntaxWrapperHelperTests.cs

@@ -50,6 +50,12 @@ public void VerifyThatWrapperClassIsPresent(Type wrapperType)
                 Assert.False(LightupHelpers.SupportsCSharp9);
                 Assert.Same(typeof(ObjectCreationExpressionSyntax), SyntaxWrapperHelper.GetWrappedType(wrapperType));
             }
+            else if (wrapperType == typeof(BaseNamespaceDeclarationSyntaxWrapper))
+            {
+                // Special case for C# 6-9 analysis compatibility
+                Assert.False(LightupHelpers.SupportsCSharp10);
+                Assert.Same(typeof(NamespaceDeclarationSyntax), SyntaxWrapperHelper.GetWrappedType(wrapperType));
+            }
             else
             {
                 Assert.Null(SyntaxWrapperHelper.GetWrappedType(wrapperType));

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs

@@ -18,7 +18,9 @@ static SyntaxWrapperHelper()
             var csharpCodeAnalysisAssembly = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly;
             var builder = ImmutableDictionary.CreateBuilder<Type, Type>();
             builder.Add(typeof(BaseExpressionColonSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseExpressionColonSyntaxWrapper.WrappedTypeName));
-            builder.Add(typeof(BaseNamespaceDeclarationSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseNamespaceDeclarationSyntaxWrapper.WrappedTypeName));
+
+            var baseNamespaceDeclarationSyntaxType = csharpCodeAnalysisAssembly.GetType(BaseNamespaceDeclarationSyntaxWrapper.WrappedTypeName) ?? csharpCodeAnalysisAssembly.GetType(BaseNamespaceDeclarationSyntaxWrapper.FallbackWrappedTypeName);
+            builder.Add(typeof(BaseNamespaceDeclarationSyntaxWrapper), baseNamespaceDeclarationSyntaxType);
 
             var objectCreationExpressionSyntaxType = csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.WrappedTypeName) ?? csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.FallbackWrappedTypeName);
             builder.Add(typeof(BaseObjectCreationExpressionSyntaxWrapper), objectCreationExpressionSyntaxType);

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/BaseNamespaceDeclarationSyntaxWrapper.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    internal partial struct BaseNamespaceDeclarationSyntaxWrapper : ISyntaxWrapper<MemberDeclarationSyntax>
+    {
+        internal const string FallbackWrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax";
+
+        public static implicit operator BaseNamespaceDeclarationSyntaxWrapper(NamespaceDeclarationSyntax node)
+        {
+            return new BaseNamespaceDeclarationSyntaxWrapper(node);
+        }
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxKindEx.cs

@@ -25,6 +25,7 @@ internal static class SyntaxKindEx
         public const SyntaxKind IndexExpression = (SyntaxKind)8741;
         public const SyntaxKind DefaultLiteralExpression = (SyntaxKind)8755;
         public const SyntaxKind LocalFunctionStatement = (SyntaxKind)8830;
+        public const SyntaxKind FileScopedNamespaceDeclaration = (SyntaxKind)8845;
         public const SyntaxKind TupleType = (SyntaxKind)8924;
         public const SyntaxKind TupleElement = (SyntaxKind)8925;
         public const SyntaxKind TupleExpression = (SyntaxKind)8926;