Implement IAttributeOperation

src/Compilers/CSharp/Portable/Binder/Binder_Attributes.cs

@@ -123,7 +123,8 @@ internal static void GetAttributes(
             beforeAttributePartBound?.Invoke(node);
             var boundAttribute = new ExecutableCodeBinder(node, this.ContainingMemberOrLambda, this).BindAttribute(node, boundAttributeType, diagnostics);
             afterAttributePartBound?.Invoke(node);
-            return (GetAttribute(boundAttribute, diagnostics), boundAttribute);
+            Debug.Assert(!boundAttribute.HasAnyErrors || boundAttribute.AttributeData.HasErrors);
+            return (boundAttribute.AttributeData, boundAttribute);
         }
 
         internal BoundAttribute BindAttribute(AttributeSyntax node, NamedTypeSymbol attributeType, BindingDiagnosticBag diagnostics)
@@ -209,43 +210,53 @@ private BoundAttribute BindAttributeCore(AttributeSyntax node, NamedTypeSymbol a
                 {
                     Error(diagnostics, ErrorCode.ERR_AttributeCtorInParameter, node, attributeConstructor.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat));
                 }
+
+                //BindDefaultArguments(node, attributeConstructor.Parameters, analyzedArguments.ConstructorArguments.Arguments, analyzedArguments.ConstructorArguments.RefKinds, ref argsToParamsOpt, out defaultArguments, expanded, enableCallerInfo: true, diagnostics);
             }
 
             ImmutableArray<string?> boundConstructorArgumentNamesOpt = analyzedArguments.ConstructorArguments.GetNames();
             ImmutableArray<BoundAssignmentOperator> boundNamedArguments = analyzedArguments.NamedArguments?.ToImmutableAndFree() ?? ImmutableArray<BoundAssignmentOperator>.Empty;
             Debug.Assert(boundNamedArguments.All(arg => !arg.Right.NeedsToBeConverted()));
 
+            // var boundAttribute = new BoundAttribute(node, attributeConstructor, analyzedArguments.ConstructorArguments.Arguments.ToImmutableArray(), boundConstructorArgumentNamesOpt, argsToParamsOpt, expanded,
+            //     boundNamedArguments, resultKind, defaultArguments, attributeType, hasErrors: resultKind != LookupResultKind.Viable);
             analyzedArguments.ConstructorArguments.Free();
-
+            //return boundAttribute;
+            var attributeData = GetAttribute(attributeType, attributeConstructor, boundConstructorArguments, boundNamedArguments, boundConstructorArgumentNamesOpt, argsToParamsOpt, node, hasErrors: resultKind != LookupResultKind.Viable, diagnostics);
             return new BoundAttribute(node, attributeConstructor, boundConstructorArguments, boundConstructorArgumentNamesOpt, argsToParamsOpt, expanded,
-                boundNamedArguments, resultKind, attributeType, hasErrors: resultKind != LookupResultKind.Viable);
+                boundNamedArguments, resultKind, attributeData, attributeType, hasErrors: resultKind != LookupResultKind.Viable);
         }
 
-        private CSharpAttributeData GetAttribute(BoundAttribute boundAttribute, BindingDiagnosticBag diagnostics)
+        private CSharpAttributeData GetAttribute(
+            NamedTypeSymbol attributeType,
+            MethodSymbol? attributeConstructor,
+            ImmutableArray<BoundExpression> boundConstructorArguments,
+            ImmutableArray<BoundAssignmentOperator> boundNamedArguments,
+            ImmutableArray<string?> constructorArgumentNamesOpt,
+            ImmutableArray<int> constructorArgumentsToParamsOpt,
+            SyntaxNode node,
+            bool hasErrors,
+            BindingDiagnosticBag diagnostics)
         {
-            var attributeType = (NamedTypeSymbol)boundAttribute.Type;
-            var attributeConstructor = boundAttribute.Constructor;
-
             RoslynDebug.Assert((object)attributeType != null);
-            Debug.Assert(boundAttribute.Syntax.Kind() == SyntaxKind.Attribute);
+            Debug.Assert(node.Kind() == SyntaxKind.Attribute);
 
-            bool hasErrors = boundAttribute.HasAnyErrors;
+            hasErrors = hasErrors || node.HasErrors || attributeType.IsErrorType() || boundConstructorArguments.HasErrors() || boundNamedArguments.HasErrors();
 
             if (attributeType.IsErrorType() || attributeType.IsAbstract || attributeConstructor is null)
             {
                 // prevent cascading diagnostics
                 Debug.Assert(hasErrors);
-                return new SourceAttributeData(boundAttribute.Syntax.GetReference(), attributeType, attributeConstructor, hasErrors);
+                return new SourceAttributeData(node.GetReference(), attributeType, attributeConstructor, hasErrors);
             }
 
             // Validate attribute constructor parameters have valid attribute parameter type
-            ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors);
+            ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)node).Name, diagnostics, ref hasErrors);
 
             // Validate the attribute arguments and generate TypedConstant for argument's BoundExpression.
             var visitor = new AttributeExpressionVisitor(this);
-            var arguments = boundAttribute.ConstructorArguments;
-            var constructorArgsArray = visitor.VisitArguments(arguments, diagnostics, ref hasErrors);
-            var namedArguments = visitor.VisitNamedArguments(boundAttribute.NamedArguments, diagnostics, ref hasErrors);
+            var constructorArgsArray = visitor.VisitArguments(boundConstructorArguments, diagnostics, ref hasErrors);
+            var namedArguments = visitor.VisitNamedArguments(boundNamedArguments, diagnostics, ref hasErrors);
 
             Debug.Assert(!constructorArgsArray.IsDefault, "Property of VisitArguments");
 
@@ -259,14 +270,14 @@ private CSharpAttributeData GetAttribute(BoundAttribute boundAttribute, BindingD
             else
             {
                 constructorArguments = GetRewrittenAttributeConstructorArguments(out constructorArgumentsSourceIndices, attributeConstructor,
-                    constructorArgsArray, boundAttribute.ConstructorArgumentNamesOpt, (AttributeSyntax)boundAttribute.Syntax, boundAttribute.ConstructorArgumentsToParamsOpt, diagnostics, ref hasErrors);
+                    constructorArgsArray, constructorArgumentNamesOpt, (AttributeSyntax)node, constructorArgumentsToParamsOpt, diagnostics, ref hasErrors);
             }
 
             CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-            bool isConditionallyOmitted = IsAttributeConditionallyOmitted(attributeType, boundAttribute.SyntaxTree, ref useSiteInfo);
-            diagnostics.Add(boundAttribute.Syntax, useSiteInfo);
+            bool isConditionallyOmitted = IsAttributeConditionallyOmitted(attributeType, node.SyntaxTree, ref useSiteInfo);
+            diagnostics.Add(node, useSiteInfo);
 
-            return new SourceAttributeData(boundAttribute.Syntax.GetReference(), attributeType, attributeConstructor, constructorArguments, constructorArgumentsSourceIndices, namedArguments, hasErrors, isConditionallyOmitted);
+            return new SourceAttributeData(node.GetReference(), attributeType, attributeConstructor, constructorArguments, constructorArgumentsSourceIndices, namedArguments, hasErrors, isConditionallyOmitted);
         }
 
         private void ValidateTypeForAttributeParameters(ImmutableArray<ParameterSymbol> parameters, CSharpSyntaxNode syntax, BindingDiagnosticBag diagnostics, ref bool hasErrors)

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -1757,6 +1757,7 @@
     <Field Name="ConstructorExpanded" Type="bool" />
     <Field Name="NamedArguments" Type ="ImmutableArray&lt;BoundAssignmentOperator&gt;"/>
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
+    <Field Name="AttributeData" Type="CSharpAttributeData" />
   </Node>
 
   <!--

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

@@ -286,8 +286,9 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                     return CreateBoundInterpolatedStringArgumentPlaceholder((BoundInterpolatedStringArgumentPlaceholder)boundNode);
                 case BoundKind.InterpolatedStringHandlerPlaceholder:
                     return CreateBoundInterpolatedStringHandlerPlaceholder((BoundInterpolatedStringHandlerPlaceholder)boundNode);
-
                 case BoundKind.Attribute:
+                    return CreateBoundAttributeOperation((BoundAttribute)boundNode);
+
                 case BoundKind.ArgList:
                 case BoundKind.ArgListOperator:
                 case BoundKind.ConvertedStackAllocExpression:
@@ -483,6 +484,53 @@ private IOperation CreateBoundUnconvertedAddressOfOperatorOperation(BoundUnconve
                 boundUnconvertedAddressOf.WasCompilerGenerated);
         }
 
+        private IOperation CreateBoundAttributeOperation(BoundAttribute boundAttribute)
+        {
+            if (boundAttribute.Constructor is null)
+            {
+                return OperationFactory.CreateInvalidOperation(_semanticModel, boundAttribute.Syntax, ImmutableArray<IOperation>.Empty, isImplicit: false);
+            }
+
+            var attributeData = boundAttribute.AttributeData;
+
+            var builder = ImmutableArray.CreateBuilder<IArgumentOperation>(boundAttribute.Constructor.ParameterCount);
+            var seenParameters = ImmutableHashSet.CreateBuilder<ParameterSymbol>();
+
+            for (int i = 0; i < boundAttribute.ConstructorArguments.Length; i++)
+            {
+                int parameterIndex = boundAttribute.ConstructorArgumentsToParamsOpt.IsDefaultOrEmpty switch
+                {
+                    true => i,
+                    false => boundAttribute.ConstructorArgumentsToParamsOpt[i],
+                };
+
+                var parameter = boundAttribute.Constructor.Parameters[parameterIndex];
+                seenParameters.Add(parameter);
+                builder.Add(CreateArgumentOperation(ArgumentKind.Explicit, parameter.GetPublicSymbol(), boundAttribute.ConstructorArguments[i]));
+            }
+
+            foreach (var parameter in boundAttribute.Constructor.Parameters)
+            {
+                if (!seenParameters.Contains(parameter))
+                {
+                    var typedConstant = attributeData.CommonConstructorArguments[parameter.Ordinal];
+                    builder.Add(CreateArgumentOperation(ArgumentKind.DefaultValue, parameter.GetPublicSymbol(), new BoundLiteral(boundAttribute.Syntax, ConstantValue.Create(typedConstant.Value!, typedConstant.Type!.SpecialType), parameter.Type) { WasCompilerGenerated = true }));
+                }
+            }
+
+            // var arguments = DeriveArguments(
+            //     methodOrIndexer: boundAttribute.Constructor,
+            //     boundArguments: boundAttribute.ConstructorArguments,
+            //     argumentsToParametersOpt: boundAttribute.ConstructorArgumentsToParamsOpt,
+            //     defaultArguments: boundAttribute.DefaultArguments,
+            //     boundAttribute.ConstructorExpanded,
+            //     boundAttribute.Syntax);
+
+            var namedArguments = CreateFromArray<BoundAssignmentOperator, ISimpleAssignmentOperation>(boundAttribute.NamedArguments);
+
+            return new AttributeOperation(builder.ToImmutable(), namedArguments, _semanticModel, boundAttribute.Syntax, boundAttribute.GetPublicTypeSymbol(), boundAttribute.WasCompilerGenerated);
+        }
+
         internal ImmutableArray<IOperation> CreateIgnoredDimensions(BoundNode declaration, SyntaxNode declarationSyntax)
         {
             switch (declaration.Kind)

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory_Methods.cs

@@ -37,7 +37,7 @@ internal IArgumentOperation CreateArgumentOperation(ArgumentKind kind, IParamete
         {
             // put argument syntax to argument operation
             IOperation value = Create(expression);
-            (SyntaxNode syntax, bool isImplicit) = expression.Syntax is { Parent: ArgumentSyntax parent } ? (parent, expression.WasCompilerGenerated) : (value.Syntax, true);
+            (SyntaxNode syntax, bool isImplicit) = expression.Syntax is { Parent: ArgumentSyntax or AttributeArgumentSyntax } ? (expression.Syntax.Parent, expression.WasCompilerGenerated) : (value.Syntax, true);
             return new ArgumentOperation(
                 kind,
                 parameter,