Generate explicit downcast

Author: sharwell

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

@@ -126,6 +126,94 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD
                 initializer: null,
                 semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
 
+            // public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node)
+            // {
+            //     if (node == null)
+            //     {
+            //         return default;
+            //     }
+            //
+            //     if (!IsInstance(node))
+            //     {
+            //         throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            //     }
+            //
+            //     return new WhenClauseSyntaxWrapper((CSharpSyntaxNode)node);
+            // }
+            members = members.Add(SyntaxFactory.ConversionOperatorDeclaration(
+                attributeLists: default,
+                modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)),
+                implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword),
+                operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
+                type: SyntaxFactory.IdentifierName(nodeData.WrapperName),
+                parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter(
+                    attributeLists: default,
+                    modifiers: default,
+                    type: SyntaxFactory.IdentifierName("SyntaxNode"),
+                    identifier: SyntaxFactory.Identifier("node"),
+                    @default: null))),
+                body: SyntaxFactory.Block(
+                    SyntaxFactory.IfStatement(
+                        condition: SyntaxFactory.BinaryExpression(
+                            SyntaxKind.EqualsExpression,
+                            left: SyntaxFactory.IdentifierName("node"),
+                            right: SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
+                        statement: SyntaxFactory.Block(
+                            SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)))),
+                    SyntaxFactory.IfStatement(
+                        condition: SyntaxFactory.PrefixUnaryExpression(
+                            SyntaxKind.LogicalNotExpression,
+                            operand: SyntaxFactory.InvocationExpression(
+                                expression: SyntaxFactory.IdentifierName("IsInstance"),
+                                argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("node")))))),
+                        statement: SyntaxFactory.Block(
+                            SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression(
+                                type: SyntaxFactory.IdentifierName("InvalidCastException"),
+                                argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                                    SyntaxFactory.InterpolatedStringExpression(
+                                        SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken),
+                                        SyntaxFactory.List(new InterpolatedStringContentSyntax[]
+                                        {
+                                            SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(
+                                                leading: default,
+                                                SyntaxKind.InterpolatedStringTextToken,
+                                                "Cannot cast '",
+                                                "Cannot cast '",
+                                                trailing: default)),
+                                            SyntaxFactory.Interpolation(SyntaxFactory.MemberAccessExpression(
+                                                SyntaxKind.SimpleMemberAccessExpression,
+                                                expression: SyntaxFactory.InvocationExpression(
+                                                    expression: SyntaxFactory.MemberAccessExpression(
+                                                        SyntaxKind.SimpleMemberAccessExpression,
+                                                        expression: SyntaxFactory.IdentifierName("node"),
+                                                        name: SyntaxFactory.IdentifierName("GetType")),
+                                                    argumentList: SyntaxFactory.ArgumentList()),
+                                                name: SyntaxFactory.IdentifierName("FullName"))),
+                                            SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(
+                                                leading: default,
+                                                SyntaxKind.InterpolatedStringTextToken,
+                                                "' to '",
+                                                "' to '",
+                                                trailing: default)),
+                                            SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName("WrappedTypeName")),
+                                            SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(
+                                                leading: default,
+                                                SyntaxKind.InterpolatedStringTextToken,
+                                                "'",
+                                                "'",
+                                                trailing: default)),
+                                        }))))),
+                                initializer: null)))),
+                    SyntaxFactory.ReturnStatement(SyntaxFactory.ObjectCreationExpression(
+                        type: SyntaxFactory.IdentifierName(nodeData.WrapperName),
+                        argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                            SyntaxFactory.CastExpression(
+                                type: SyntaxFactory.IdentifierName(concreteBase),
+                                expression: SyntaxFactory.IdentifierName("node"))))),
+                        initializer: null))),
+                expressionBody: null,
+                semicolonToken: default));
+
             // public static implicit operator CSharpSyntaxNode(SyntaxWrapper wrapper)
             // {
             //     return wrapper.node;

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

@@ -20,6 +20,21 @@ private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node)
         }
 
         public ExpressionSyntax SyntaxNode => this.node;
+        public static explicit operator BaseObjectCreationExpressionSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new BaseObjectCreationExpressionSyntaxWrapper((ExpressionSyntax)node);
+        }
+
         public static implicit operator ExpressionSyntax(BaseObjectCreationExpressionSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private BaseParameterSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static explicit operator BaseParameterSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new BaseParameterSyntaxWrapper((CSharpSyntaxNode)node);
+        }
+
         public static implicit operator CSharpSyntaxNode(BaseParameterSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static explicit operator BinaryPatternSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new BinaryPatternSyntaxWrapper((CSharpSyntaxNode)node);
+        }
+
         public static implicit operator CSharpSyntaxNode(BinaryPatternSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node)
         }
 
         public SwitchLabelSyntax SyntaxNode => this.node;
+        public static explicit operator CasePatternSwitchLabelSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new CasePatternSwitchLabelSyntaxWrapper((SwitchLabelSyntax)node);
+        }
+
         public static implicit operator SwitchLabelSyntax(CasePatternSwitchLabelSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private CommonForEachStatementSyntaxWrapper(StatementSyntax node)
         }
 
         public StatementSyntax SyntaxNode => this.node;
+        public static explicit operator CommonForEachStatementSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new CommonForEachStatementSyntaxWrapper((StatementSyntax)node);
+        }
+
         public static implicit operator StatementSyntax(CommonForEachStatementSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static explicit operator ConstantPatternSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new ConstantPatternSyntaxWrapper((CSharpSyntaxNode)node);
+        }
+
         public static implicit operator CSharpSyntaxNode(ConstantPatternSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node)
         }
 
         public ExpressionSyntax SyntaxNode => this.node;
+        public static explicit operator DeclarationExpressionSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new DeclarationExpressionSyntaxWrapper((ExpressionSyntax)node);
+        }
+
         public static implicit operator ExpressionSyntax(DeclarationExpressionSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node)
         }
 
         public CSharpSyntaxNode SyntaxNode => this.node;
+        public static explicit operator DeclarationPatternSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new DeclarationPatternSyntaxWrapper((CSharpSyntaxNode)node);
+        }
+
         public static implicit operator CSharpSyntaxNode(DeclarationPatternSyntaxWrapper wrapper)
         {
             return wrapper.node;

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

@@ -20,6 +20,21 @@ private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node)
         }
 
         public TypeParameterConstraintSyntax SyntaxNode => this.node;
+        public static explicit operator DefaultConstraintSyntaxWrapper(SyntaxNode node)
+        {
+            if (node == null)
+            {
+                return default;
+            }
+
+            if (!IsInstance(node))
+            {
+                throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'");
+            }
+
+            return new DefaultConstraintSyntaxWrapper((TypeParameterConstraintSyntax)node);
+        }
+
         public static implicit operator TypeParameterConstraintSyntax(DefaultConstraintSyntaxWrapper wrapper)
         {
             return wrapper.node;