VB support for CallerArgumentExpression (#54132)

Proposal: dotnet/csharplang#287 Test plan: #52745 Addresses part of LDM notes: https://github.com/dotnet/csharplang/blob/main/meetings/2021/LDM-2021-06-14.md
dotnet · Jun 29, 2021 · af4b1e1 · af4b1e1
1 parent 93b0c43
commit af4b1e1
Show file tree

Hide file tree

Showing 56 changed files with 2,300 additions and 140 deletions.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
@@ -1375,7 +1375,6 @@ BoundExpression bindDefaultArgument(SyntaxNode syntax, ParameterSymbol parameter
                     argumentIndex > -1 && argumentIndex < argumentsCount)
                 {
                     CheckFeatureAvailability(syntax, MessageID.IDS_FeatureCallerArgumentExpression, diagnostics);
-                    // PROTOTYPE(caller-expr): Do we need to support VB?
 
                     var argument = argumentsBuilder[argumentIndex];
                     defaultValue = new BoundLiteral(syntax, ConstantValue.Create(argument.Syntax.ToString()), Compilation.GetSpecialType(SpecialType.System_String)) { WasCompilerGenerated = true };

diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs
@@ -686,7 +686,7 @@ internal override int CallerArgumentExpressionParameterIndex
                     var parameters = ContainingSymbol.GetParameters();
                     for (int i = 0; i < parameters.Length; i++)
                     {
-                        if (parameters[i].Name == parameterName)
+                        if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal))
                         {
                             _lazyCallerArgumentExpressionParameterIndex = i;
                             return i;

diff --git a/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs
@@ -376,6 +376,14 @@ internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, Na
 
         public override ImmutableArray<CustomModifier> RefCustomModifiers => _underlyingParameter.RefCustomModifiers;
 
+        internal override bool IsCallerLineNumber => _underlyingParameter.IsCallerLineNumber;
+
+        internal override bool IsCallerFilePath => _underlyingParameter.IsCallerFilePath;
+
+        internal override bool IsCallerMemberName => _underlyingParameter.IsCallerMemberName;
+
+        internal override int CallerArgumentExpressionParameterIndex => _underlyingParameter.CallerArgumentExpressionParameterIndex;
+
         public override bool Equals(Symbol? other, TypeCompareKind comparison) => NativeIntegerTypeSymbol.EqualsHelper(this, other, comparison, symbol => symbol._underlyingParameter);
 
         public override int GetHashCode() => _underlyingParameter.GetHashCode();

diff --git a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
@@ -621,6 +621,30 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
                 }
             }
 
+            internal override bool IsCallerLineNumber
+            {
+                // ReducedExtensionMethodParameterSymbol is only exposed to semantic model.
+                get { throw ExceptionUtilities.Unreachable; }
+            }
+
+            internal override bool IsCallerFilePath
+            {
+                // ReducedExtensionMethodParameterSymbol is only exposed to semantic model.
+                get { throw ExceptionUtilities.Unreachable; }
+            }
+
+            internal override bool IsCallerMemberName
+            {
+                // ReducedExtensionMethodParameterSymbol is only exposed to semantic model.
+                get { throw ExceptionUtilities.Unreachable; }
+            }
+
+            internal override int CallerArgumentExpressionParameterIndex
+            {
+                // ReducedExtensionMethodParameterSymbol is only exposed to semantic model.
+                get { throw ExceptionUtilities.Unreachable; }
+            }
+
             public sealed override bool Equals(Symbol obj, TypeCompareKind compareKind)
             {
                 if ((object)this == obj)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs
@@ -142,6 +142,26 @@ protected override RetargetingModuleSymbol RetargetingModule
         {
             get { return _retargetingMethod.RetargetingModule; }
         }
+
+        internal override bool IsCallerLineNumber
+        {
+            get { return _underlyingParameter.IsCallerLineNumber; }
+        }
+
+        internal override bool IsCallerFilePath
+        {
+            get { return _underlyingParameter.IsCallerFilePath; }
+        }
+
+        internal override bool IsCallerMemberName
+        {
+            get { return _underlyingParameter.IsCallerMemberName; }
+        }
+
+        internal override int CallerArgumentExpressionParameterIndex
+        {
+            get { return _underlyingParameter.CallerArgumentExpressionParameterIndex; }
+        }
     }
 
     internal sealed class RetargetingPropertyParameterSymbol : RetargetingParameterSymbol
@@ -162,5 +182,25 @@ protected override RetargetingModuleSymbol RetargetingModule
         {
             get { return _retargetingProperty.RetargetingModule; }
         }
+
+        internal override bool IsCallerLineNumber
+        {
+            get { return _underlyingParameter.IsCallerLineNumber; }
+        }
+
+        internal override bool IsCallerFilePath
+        {
+            get { return _underlyingParameter.IsCallerFilePath; }
+        }
+
+        internal override bool IsCallerMemberName
+        {
+            get { return _underlyingParameter.IsCallerMemberName; }
+        }
+
+        internal override int CallerArgumentExpressionParameterIndex
+        {
+            get { return _underlyingParameter.CallerArgumentExpressionParameterIndex; }
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceClonedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceClonedParameterSymbol.cs
@@ -10,6 +10,9 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
+
+    // PROTOTYPE(caller-expr): Make SourceClonedParameterSymbol abstract and introduce new specialized types (same as being done in VB).
+
     /// <summary>
     /// Represents a source parameter cloned from another <see cref="SourceParameterSymbol"/>, when they must share attribute data and default constant value.
     /// For example, parameters on a property symbol are cloned to generate parameters on accessors.

diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
@@ -611,7 +611,7 @@ internal override CSharpAttributeData EarlyDecodeWellKnownAttribute(ref EarlyDec
                             var parameters = ContainingSymbol.GetParameters();
                             for (int i = 0; i < parameters.Length; i++)
                             {
-                                if (parameters[i].Name == parameterName)
+                                if (parameters[i].Name.Equals(parameterName, StringComparison.Ordinal))
                                 {
                                     index = i;
                                     break;

diff --git a/src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs
@@ -77,6 +77,26 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
             }
         }
 
+        internal override bool IsCallerLineNumber
+        {
+            get { return _underlyingParameter.IsCallerLineNumber; }
+        }
+
+        internal override bool IsCallerFilePath
+        {
+            get { return _underlyingParameter.IsCallerFilePath; }
+        }
+
+        internal override bool IsCallerMemberName
+        {
+            get { return _underlyingParameter.IsCallerMemberName; }
+        }
+
+        internal override int CallerArgumentExpressionParameterIndex
+        {
+            get { return _underlyingParameter.CallerArgumentExpressionParameterIndex; }
+        }
+
         public sealed override bool Equals(Symbol obj, TypeCompareKind compareKind)
         {
             if ((object)this == obj)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs
@@ -138,26 +138,6 @@ internal override bool IsIUnknownConstant
             get { return _underlyingParameter.IsIUnknownConstant; }
         }
 
-        internal override bool IsCallerLineNumber
-        {
-            get { return _underlyingParameter.IsCallerLineNumber; }
-        }
-
-        internal override bool IsCallerFilePath
-        {
-            get { return _underlyingParameter.IsCallerFilePath; }
-        }
-
-        internal override bool IsCallerMemberName
-        {
-            get { return _underlyingParameter.IsCallerMemberName; }
-        }
-
-        internal override int CallerArgumentExpressionParameterIndex
-        {
-            get { return _underlyingParameter.CallerArgumentExpressionParameterIndex; }
-        }
-
         internal override FlowAnalysisAnnotations FlowAnalysisAnnotations
         {
             // https://github.com/dotnet/roslyn/issues/30073: Consider moving to leaf types