Rewrite IOperationWrapper as a wrapper structure around IOperation

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs

@@ -310,6 +310,57 @@ private void GenerateOperationInterface(in SourceProductionContext context, Inte
                     semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
             }
 
+            // public static explicit operator IFieldReferenceOperationWrapper(IOperationWrapper wrapper)
+            //     => FromOperation(wrapper.WrappedOperation);
+            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(node.WrapperName),
+                parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter(
+                    attributeLists: default,
+                    modifiers: default,
+                    type: SyntaxFactory.IdentifierName("IOperationWrapper"),
+                    identifier: SyntaxFactory.Identifier("wrapper"),
+                    @default: null))),
+                body: null,
+                expressionBody: SyntaxFactory.ArrowExpressionClause(SyntaxFactory.InvocationExpression(
+                    expression: SyntaxFactory.IdentifierName("FromOperation"),
+                    argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                        SyntaxFactory.MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            expression: SyntaxFactory.IdentifierName("wrapper"),
+                            name: SyntaxFactory.IdentifierName("WrappedOperation"))))))),
+                semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
+
+            // public static implicit operator IOperationWrapper(IFieldReferenceOperationWrapper wrapper)
+            //     => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
+            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("IOperationWrapper"),
+                parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter(
+                    attributeLists: default,
+                    modifiers: default,
+                    type: SyntaxFactory.IdentifierName(node.WrapperName),
+                    identifier: SyntaxFactory.Identifier("wrapper"),
+                    @default: null))),
+                body: null,
+                expressionBody: SyntaxFactory.ArrowExpressionClause(SyntaxFactory.InvocationExpression(
+                    expression: SyntaxFactory.MemberAccessExpression(
+                        SyntaxKind.SimpleMemberAccessExpression,
+                        expression: SyntaxFactory.IdentifierName("IOperationWrapper"),
+                        name: SyntaxFactory.IdentifierName("FromUpcast")),
+                    argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
+                        SyntaxFactory.MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            expression: SyntaxFactory.IdentifierName("wrapper"),
+                            name: SyntaxFactory.IdentifierName("WrappedOperation"))))))),
+                semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
+
             if (node.BaseInterface is { } baseDefinition)
             {
                 var inheritedProperties = baseDefinition.Properties;
@@ -556,7 +607,7 @@ private void GenerateOperationInterface(in SourceProductionContext context, Inte
                 modifiers: SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.InternalKeyword)).Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)),
                 identifier: SyntaxFactory.Identifier(node.WrapperName),
                 typeParameterList: null,
-                baseList: SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList<BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(SyntaxFactory.IdentifierName("IOperationWrapper")))),
+                baseList: null,
                 constraintClauses: default,
                 members: members);
             var wrapperNamespace = SyntaxFactory.NamespaceDeclaration(
@@ -637,6 +688,21 @@ private void GenerateOperationWrapperHelper(in SourceProductionContext context,
                                                     SyntaxFactory.IdentifierName("Type"),
                                                 })))))))))));
 
+            // builder.Add(typeof(IOperationWrapper), typeof(IOperation));
+            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("IOperationWrapper"))),
+                                SyntaxFactory.Argument(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName("IOperation"))),
+                            })))));
+
             foreach (var node in wrapperTypes)
             {
                 // builder.Add(typeof(IArgumentOperationWrapper), codeAnalysisAssembly.GetType(IArgumentOperationWrapper.WrappedTypeName));

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IAddressOfOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IAddressOfOperationWrapper : IOperationWrapper
+    internal readonly struct IAddressOfOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IAddressOfOperation";
         private static readonly Type WrappedType;
@@ -27,6 +27,8 @@ private IAddressOfOperationWrapper(IOperation operation)
         public IOperation WrappedOperation => this.operation;
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public IOperation Reference => ReferenceAccessor(this.WrappedOperation);
+        public static explicit operator IAddressOfOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IAddressOfOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IAddressOfOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IAnonymousFunctionOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IAnonymousFunctionOperationWrapper : IOperationWrapper
+    internal readonly struct IAnonymousFunctionOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IAnonymousFunctionOperation";
         private static readonly Type WrappedType;
@@ -30,6 +30,8 @@ private IAnonymousFunctionOperationWrapper(IOperation operation)
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public IMethodSymbol Symbol => SymbolAccessor(this.WrappedOperation);
         public IBlockOperationWrapper Body => IBlockOperationWrapper.FromOperation(BodyAccessor(this.WrappedOperation));
+        public static explicit operator IAnonymousFunctionOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IAnonymousFunctionOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IAnonymousFunctionOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IAnonymousObjectCreationOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IAnonymousObjectCreationOperationWrapper : IOperationWrapper
+    internal readonly struct IAnonymousObjectCreationOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IAnonymousObjectCreationOperation";
         private static readonly Type WrappedType;
@@ -27,6 +27,8 @@ private IAnonymousObjectCreationOperationWrapper(IOperation operation)
         public IOperation WrappedOperation => this.operation;
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public ImmutableArray<IOperation> Initializers => InitializersAccessor(this.WrappedOperation);
+        public static explicit operator IAnonymousObjectCreationOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IAnonymousObjectCreationOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IAnonymousObjectCreationOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IArgumentOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IArgumentOperationWrapper : IOperationWrapper
+    internal readonly struct IArgumentOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IArgumentOperation";
         private static readonly Type WrappedType;
@@ -33,6 +33,8 @@ private IArgumentOperationWrapper(IOperation operation)
         public IOperation Value => ValueAccessor(this.WrappedOperation);
         public object InConversion => throw new NotImplementedException("Property 'IArgumentOperation.InConversion' has unsupported type 'CommonConversion'");
         public object OutConversion => throw new NotImplementedException("Property 'IArgumentOperation.OutConversion' has unsupported type 'CommonConversion'");
+        public static explicit operator IArgumentOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IArgumentOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IArgumentOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IArrayCreationOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IArrayCreationOperationWrapper : IOperationWrapper
+    internal readonly struct IArrayCreationOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IArrayCreationOperation";
         private static readonly Type WrappedType;
@@ -30,6 +30,8 @@ private IArrayCreationOperationWrapper(IOperation operation)
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public ImmutableArray<IOperation> DimensionSizes => DimensionSizesAccessor(this.WrappedOperation);
         public IArrayInitializerOperationWrapper Initializer => IArrayInitializerOperationWrapper.FromOperation(InitializerAccessor(this.WrappedOperation));
+        public static explicit operator IArrayCreationOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IArrayCreationOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IArrayCreationOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IArrayElementReferenceOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IArrayElementReferenceOperationWrapper : IOperationWrapper
+    internal readonly struct IArrayElementReferenceOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IArrayElementReferenceOperation";
         private static readonly Type WrappedType;
@@ -30,6 +30,8 @@ private IArrayElementReferenceOperationWrapper(IOperation operation)
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public IOperation ArrayReference => ArrayReferenceAccessor(this.WrappedOperation);
         public ImmutableArray<IOperation> Indices => IndicesAccessor(this.WrappedOperation);
+        public static explicit operator IArrayElementReferenceOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IArrayElementReferenceOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IArrayElementReferenceOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IArrayInitializerOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IArrayInitializerOperationWrapper : IOperationWrapper
+    internal readonly struct IArrayInitializerOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IArrayInitializerOperation";
         private static readonly Type WrappedType;
@@ -27,6 +27,8 @@ private IArrayInitializerOperationWrapper(IOperation operation)
         public IOperation WrappedOperation => this.operation;
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public ImmutableArray<IOperation> ElementValues => ElementValuesAccessor(this.WrappedOperation);
+        public static explicit operator IArrayInitializerOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IArrayInitializerOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IArrayInitializerOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IAssignmentOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IAssignmentOperationWrapper : IOperationWrapper
+    internal readonly struct IAssignmentOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IAssignmentOperation";
         private static readonly Type WrappedType;
@@ -30,6 +30,8 @@ private IAssignmentOperationWrapper(IOperation operation)
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public IOperation Target => TargetAccessor(this.WrappedOperation);
         public IOperation Value => ValueAccessor(this.WrappedOperation);
+        public static explicit operator IAssignmentOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IAssignmentOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IAssignmentOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/IAwaitOperationWrapper.g.cs

@@ -7,7 +7,7 @@ namespace StyleCop.Analyzers.Lightup
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
 
-    internal readonly struct IAwaitOperationWrapper : IOperationWrapper
+    internal readonly struct IAwaitOperationWrapper
     {
         internal const string WrappedTypeName = "Microsoft.CodeAnalysis.Operations.IAwaitOperation";
         private static readonly Type WrappedType;
@@ -27,6 +27,8 @@ private IAwaitOperationWrapper(IOperation operation)
         public IOperation WrappedOperation => this.operation;
         public ITypeSymbol Type => this.WrappedOperation.Type;
         public IOperation Operation => OperationAccessor(this.WrappedOperation);
+        public static explicit operator IAwaitOperationWrapper(IOperationWrapper wrapper) => FromOperation(wrapper.WrappedOperation);
+        public static implicit operator IOperationWrapper(IAwaitOperationWrapper wrapper) => IOperationWrapper.FromUpcast(wrapper.WrappedOperation);
         public static IAwaitOperationWrapper FromOperation(IOperation operation)
         {
             if (operation == null)