Generate implicit upcast and IsInstance

Author: sharwell

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

@@ -126,6 +126,67 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD
                 initializer: null,
                 semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
 
+            // public static implicit operator CSharpSyntaxNode(SyntaxWrapper wrapper)
+            // {
+            //     return wrapper.node;
+            // }
+            members = members.Add(SyntaxFactory.ConversionOperatorDeclaration(
+                attributeLists: default,
+                modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)),
+                implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ImplicitKeyword),
+                operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
+                type: SyntaxFactory.IdentifierName(concreteBase),
+                parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter(
+                    attributeLists: default,
+                    modifiers: default,
+                    type: SyntaxFactory.IdentifierName(nodeData.WrapperName),
+                    identifier: SyntaxFactory.Identifier("wrapper"),
+                    @default: null))),
+                body: SyntaxFactory.Block(SyntaxFactory.ReturnStatement(SyntaxFactory.MemberAccessExpression(
+                    SyntaxKind.SimpleMemberAccessExpression,
+                    expression: SyntaxFactory.IdentifierName("wrapper"),
+                    name: SyntaxFactory.IdentifierName("node")))),
+                expressionBody: null,
+                semicolonToken: default));
+
+            // public static bool IsInstance(SyntaxNode node)
+            // {
+            //     return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+            // }
+            members = members.Add(SyntaxFactory.MethodDeclaration(
+                attributeLists: default,
+                modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)),
+                returnType: SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)),
+                explicitInterfaceSpecifier: null,
+                identifier: SyntaxFactory.Identifier("IsInstance"),
+                typeParameterList: null,
+                parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter(
+                    attributeLists: default,
+                    modifiers: default,
+                    type: SyntaxFactory.IdentifierName("SyntaxNode"),
+                    identifier: SyntaxFactory.Identifier("node"),
+                    @default: null))),
+                constraintClauses: default,
+                body: SyntaxFactory.Block(
+                    SyntaxFactory.ReturnStatement(SyntaxFactory.BinaryExpression(
+                        SyntaxKind.LogicalAndExpression,
+                        left: SyntaxFactory.BinaryExpression(
+                            SyntaxKind.NotEqualsExpression,
+                            left: SyntaxFactory.IdentifierName("node"),
+                            right: SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
+                        right: SyntaxFactory.InvocationExpression(
+                            expression: SyntaxFactory.MemberAccessExpression(
+                                SyntaxKind.SimpleMemberAccessExpression,
+                                expression: SyntaxFactory.IdentifierName("LightupHelpers"),
+                                name: SyntaxFactory.IdentifierName("CanWrapNode")),
+                            argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(
+                                new[]
+                                {
+                                    SyntaxFactory.Argument(SyntaxFactory.IdentifierName("node")),
+                                    SyntaxFactory.Argument(SyntaxFactory.IdentifierName("WrappedType")),
+                                })))))),
+                expressionBody: null));
+
             var wrapperStruct = SyntaxFactory.StructDeclaration(
                 attributeLists: default,
                 modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword)),

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

@@ -20,5 +20,14 @@ private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node)
         }
 
         public ExpressionSyntax SyntaxNode => this.node;
+        public static implicit operator ExpressionSyntax(BaseObjectCreationExpressionSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private BaseParameterSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static implicit operator CSharpSyntaxNode(BaseParameterSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static implicit operator CSharpSyntaxNode(BinaryPatternSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node)
         }
 
         public SwitchLabelSyntax SyntaxNode => this.node;
+        public static implicit operator SwitchLabelSyntax(CasePatternSwitchLabelSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private CommonForEachStatementSyntaxWrapper(StatementSyntax node)
         }
 
         public StatementSyntax SyntaxNode => this.node;
+        public static implicit operator StatementSyntax(CommonForEachStatementSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static implicit operator CSharpSyntaxNode(ConstantPatternSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node)
         }
 
         public ExpressionSyntax SyntaxNode => this.node;
+        public static implicit operator ExpressionSyntax(DeclarationExpressionSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static implicit operator CSharpSyntaxNode(DeclarationPatternSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }

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

@@ -20,5 +20,14 @@ private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node)
         }
 
         public TypeParameterConstraintSyntax SyntaxNode => this.node;
+        public static implicit operator TypeParameterConstraintSyntax(DefaultConstraintSyntaxWrapper wrapper)
+        {
+            return wrapper.node;
+        }
+
+        public static bool IsInstance(SyntaxNode node)
+        {
+            return node != null && LightupHelpers.CanWrapNode(node, WrappedType);
+        }
     }
 }