Generate property accessors

Author: sharwell

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

@@ -88,6 +88,59 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD
                     type: SyntaxFactory.IdentifierName(concreteBase),
                     variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node")))));
 
+            foreach (var field in nodeData.Fields)
+            {
+                if (field.IsSkipped)
+                {
+                    continue;
+                }
+
+                if (field.IsOverride)
+                {
+                    // The 'get' accessor is skipped for override fields
+                    continue;
+                }
+
+                // private static readonly Func<CSharpSyntaxNode, T> FieldAccessor;
+                members = members.Add(SyntaxFactory.FieldDeclaration(
+                    attributeLists: default,
+                    modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)),
+                    declaration: SyntaxFactory.VariableDeclaration(
+                        type: SyntaxFactory.GenericName(
+                            identifier: SyntaxFactory.Identifier("Func"),
+                            typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(
+                                new[]
+                                {
+                                    SyntaxFactory.IdentifierName(concreteBase),
+                                    SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)),
+                                }))),
+                        variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.AccessorName)))));
+            }
+
+            foreach (var field in nodeData.Fields)
+            {
+                if (field.IsSkipped)
+                {
+                    continue;
+                }
+
+                // private static readonly Func<CSharpSyntaxNode, T, CSharpSyntaxNode> WithFieldAccessor;
+                members = members.Add(SyntaxFactory.FieldDeclaration(
+                    attributeLists: default,
+                    modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)),
+                    declaration: SyntaxFactory.VariableDeclaration(
+                        type: SyntaxFactory.GenericName(
+                            identifier: SyntaxFactory.Identifier("Func"),
+                            typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(
+                                new[]
+                                {
+                                    SyntaxFactory.IdentifierName(concreteBase),
+                                    SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)),
+                                    SyntaxFactory.IdentifierName(concreteBase),
+                                }))),
+                        variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.WithAccessorName)))));
+            }
+
             // private SyntaxNodeWrapper(SyntaxNode node)
             // {
             //     this.node = node;
@@ -602,9 +655,9 @@ public SyntaxData(in GeneratorExecutionContext context, XDocument document)
 
             public ImmutableArray<NodeData> Nodes { get; }
 
-            public NodeData TryGetConcreteBase(NodeData node)
+            public NodeData TryGetConcreteType(NodeData node)
             {
-                for (var current = this.TryGetNode(node.BaseName); current is not null; current = this.TryGetNode(current.BaseName))
+                for (var current = node; current is not null; current = this.TryGetNode(current.BaseName))
                 {
                     if (current.WrapperName is null)
                     {
@@ -616,7 +669,12 @@ public NodeData TryGetConcreteBase(NodeData node)
                 return null;
             }
 
-            private NodeData TryGetNode(string name)
+            public NodeData TryGetConcreteBase(NodeData node)
+            {
+                return this.TryGetConcreteType(this.TryGetNode(node.BaseName));
+            }
+
+            public NodeData TryGetNode(string name)
             {
                 this.nameToNode.TryGetValue(name, out var node);
                 return node;
@@ -650,7 +708,7 @@ public NodeData(in GeneratorExecutionContext context, XElement element)
                 }
 
                 this.BaseName = element.Attribute("Base").Value;
-                this.Fields = element.XPathSelectElements("Field").Select(field => new FieldData(field)).ToImmutableArray();
+                this.Fields = element.XPathSelectElements("descendant::Field").Select(field => new FieldData(field)).ToImmutableArray();
             }
 
             public NodeKind Kind { get; }
@@ -669,15 +727,52 @@ private sealed class FieldData
             public FieldData(XElement element)
             {
                 this.Name = element.Attribute("Name").Value;
-                this.Type = element.Attribute("Type").Value;
+
+                var type = element.Attribute("Type").Value;
+                this.Type = type switch
+                {
+                    "SyntaxList<SyntaxToken>" => nameof(SyntaxTokenList),
+                    _ => type,
+                };
+
                 this.IsOverride = element.Attribute("Override")?.Value == "true";
+
+                this.AccessorName = this.Name + "Accessor";
+                this.WithAccessorName = "With" + this.Name + "Accessor";
             }
 
+            public bool IsSkipped => false;
+
             public string Name { get; }
 
+            public string AccessorName { get; }
+
+            public string WithAccessorName { get; }
+
             public string Type { get; }
 
             public bool IsOverride { get; }
+
+            public string GetAccessorResultType(SyntaxData syntaxData)
+            {
+                var typeNode = syntaxData.TryGetNode(this.Type);
+                if (typeNode is not null)
+                {
+                    return syntaxData.TryGetConcreteType(typeNode)?.Name ?? nameof(SyntaxNode);
+                }
+
+                if (this.Type.StartsWith("SeparatedSyntaxList<") && this.Type.EndsWith(">"))
+                {
+                    var elementTypeName = this.Type.Substring("SeparatedSyntaxList<".Length, this.Type.Length - "SeparatedSyntaxList<".Length - ">".Length);
+                    var elementTypeNode = syntaxData.TryGetNode(elementTypeName);
+                    if (elementTypeNode is { WrapperName: not null })
+                    {
+                        return $"SeparatedSyntaxListWrapper<{elementTypeNode.WrapperName}>";
+                    }
+                }
+
+                return this.Type;
+            }
         }
     }
 }

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

@@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax";
         private static readonly Type WrappedType;
         private readonly ExpressionSyntax node;
+        private static readonly Func<ExpressionSyntax, SyntaxToken> NewKeywordAccessor;
+        private static readonly Func<ExpressionSyntax, ArgumentListSyntax> ArgumentListAccessor;
+        private static readonly Func<ExpressionSyntax, InitializerExpressionSyntax> InitializerAccessor;
+        private static readonly Func<ExpressionSyntax, SyntaxToken, ExpressionSyntax> WithNewKeywordAccessor;
+        private static readonly Func<ExpressionSyntax, ArgumentListSyntax, ExpressionSyntax> WithArgumentListAccessor;
+        private static readonly Func<ExpressionSyntax, InitializerExpressionSyntax, ExpressionSyntax> WithInitializerAccessor;
         private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node)
         {
             this.node = node;

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

@@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax";
         private static readonly Type WrappedType;
         private readonly CSharpSyntaxNode node;
+        private static readonly Func<CSharpSyntaxNode, SyntaxList<AttributeListSyntax>> AttributeListsAccessor;
+        private static readonly Func<CSharpSyntaxNode, SyntaxTokenList> ModifiersAccessor;
+        private static readonly Func<CSharpSyntaxNode, TypeSyntax> TypeAccessor;
+        private static readonly Func<CSharpSyntaxNode, SyntaxList<AttributeListSyntax>, CSharpSyntaxNode> WithAttributeListsAccessor;
+        private static readonly Func<CSharpSyntaxNode, SyntaxTokenList, CSharpSyntaxNode> WithModifiersAccessor;
+        private static readonly Func<CSharpSyntaxNode, TypeSyntax, CSharpSyntaxNode> WithTypeAccessor;
         private BaseParameterSyntaxWrapper(CSharpSyntaxNode node)
         {
             this.node = node;

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

@@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax";
         private static readonly Type WrappedType;
         private readonly CSharpSyntaxNode node;
+        private static readonly Func<CSharpSyntaxNode, CSharpSyntaxNode> LeftAccessor;
+        private static readonly Func<CSharpSyntaxNode, SyntaxToken> OperatorTokenAccessor;
+        private static readonly Func<CSharpSyntaxNode, CSharpSyntaxNode> RightAccessor;
+        private static readonly Func<CSharpSyntaxNode, CSharpSyntaxNode, CSharpSyntaxNode> WithLeftAccessor;
+        private static readonly Func<CSharpSyntaxNode, SyntaxToken, CSharpSyntaxNode> WithOperatorTokenAccessor;
+        private static readonly Func<CSharpSyntaxNode, CSharpSyntaxNode, CSharpSyntaxNode> WithRightAccessor;
         private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node)
         {
             this.node = node;

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

@@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax";
         private static readonly Type WrappedType;
         private readonly SwitchLabelSyntax node;
+        private static readonly Func<SwitchLabelSyntax, CSharpSyntaxNode> PatternAccessor;
+        private static readonly Func<SwitchLabelSyntax, CSharpSyntaxNode> WhenClauseAccessor;
+        private static readonly Func<SwitchLabelSyntax, SyntaxToken, SwitchLabelSyntax> WithKeywordAccessor;
+        private static readonly Func<SwitchLabelSyntax, CSharpSyntaxNode, SwitchLabelSyntax> WithPatternAccessor;
+        private static readonly Func<SwitchLabelSyntax, CSharpSyntaxNode, SwitchLabelSyntax> WithWhenClauseAccessor;
+        private static readonly Func<SwitchLabelSyntax, SyntaxToken, SwitchLabelSyntax> WithColonTokenAccessor;
         private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node)
         {
             this.node = node;

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

@@ -14,6 +14,20 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax";
         private static readonly Type WrappedType;
         private readonly StatementSyntax node;
+        private static readonly Func<StatementSyntax, SyntaxToken> AwaitKeywordAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken> ForEachKeywordAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken> OpenParenTokenAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken> InKeywordAccessor;
+        private static readonly Func<StatementSyntax, ExpressionSyntax> ExpressionAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken> CloseParenTokenAccessor;
+        private static readonly Func<StatementSyntax, StatementSyntax> StatementAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken, StatementSyntax> WithAwaitKeywordAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken, StatementSyntax> WithForEachKeywordAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken, StatementSyntax> WithOpenParenTokenAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken, StatementSyntax> WithInKeywordAccessor;
+        private static readonly Func<StatementSyntax, ExpressionSyntax, StatementSyntax> WithExpressionAccessor;
+        private static readonly Func<StatementSyntax, SyntaxToken, StatementSyntax> WithCloseParenTokenAccessor;
+        private static readonly Func<StatementSyntax, StatementSyntax, StatementSyntax> WithStatementAccessor;
         private CommonForEachStatementSyntaxWrapper(StatementSyntax node)
         {
             this.node = node;

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

@@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax";
         private static readonly Type WrappedType;
         private readonly CSharpSyntaxNode node;
+        private static readonly Func<CSharpSyntaxNode, ExpressionSyntax> ExpressionAccessor;
+        private static readonly Func<CSharpSyntaxNode, ExpressionSyntax, CSharpSyntaxNode> WithExpressionAccessor;
         private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node)
         {
             this.node = node;

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

@@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax";
         private static readonly Type WrappedType;
         private readonly ExpressionSyntax node;
+        private static readonly Func<ExpressionSyntax, TypeSyntax> TypeAccessor;
+        private static readonly Func<ExpressionSyntax, CSharpSyntaxNode> DesignationAccessor;
+        private static readonly Func<ExpressionSyntax, TypeSyntax, ExpressionSyntax> WithTypeAccessor;
+        private static readonly Func<ExpressionSyntax, CSharpSyntaxNode, ExpressionSyntax> WithDesignationAccessor;
         private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node)
         {
             this.node = node;

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

@@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax";
         private static readonly Type WrappedType;
         private readonly CSharpSyntaxNode node;
+        private static readonly Func<CSharpSyntaxNode, TypeSyntax> TypeAccessor;
+        private static readonly Func<CSharpSyntaxNode, CSharpSyntaxNode> DesignationAccessor;
+        private static readonly Func<CSharpSyntaxNode, TypeSyntax, CSharpSyntaxNode> WithTypeAccessor;
+        private static readonly Func<CSharpSyntaxNode, CSharpSyntaxNode, CSharpSyntaxNode> WithDesignationAccessor;
         private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node)
         {
             this.node = node;

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

@@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax";
         private static readonly Type WrappedType;
         private readonly TypeParameterConstraintSyntax node;
+        private static readonly Func<TypeParameterConstraintSyntax, SyntaxToken> DefaultKeywordAccessor;
+        private static readonly Func<TypeParameterConstraintSyntax, SyntaxToken, TypeParameterConstraintSyntax> WithDefaultKeywordAccessor;
         private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node)
         {
             this.node = node;