Extensions: remove PROTOTYPE comments (#77836)

Author: jcouv

src/Compilers/CSharp/CSharpAnalyzerDriver/CSharpDeclarationComputer.cs

@@ -102,7 +102,7 @@ private static void ComputeDeclarations(
                 case SyntaxKind.StructDeclaration:
                 case SyntaxKind.RecordDeclaration:
                 case SyntaxKind.RecordStructDeclaration:
-                    // PROTOTYPE likely needs work for analyzers
+                    // Tracked by https://github.com/dotnet/roslyn/issues/76130 : likely needs work for analyzers
                     {
                         if (associatedSymbol is IMethodSymbol ctor)
                         {

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

@@ -1467,7 +1467,7 @@ static ImmutableArray<MethodSymbol> filterOutBadGenericMethods(
 
                     if (!typeParameters.IsEmpty)
                     {
-                        if (resolution.IsExtensionMethodGroup) // PROTOTYPE we need to handle new extension methods
+                        if (resolution.IsExtensionMethodGroup) // Tracked by https://github.com/dotnet/roslyn/issues/76130 : we need to handle new extension methods
                         {
                             // We need to validate an ability to infer type arguments as well as check conversion to 'this' parameter.
                             // Overload resolution doesn't check the conversion when 'this' type refers to a type parameter
@@ -1518,7 +1518,7 @@ static ImmutableArray<MethodSymbol> filterOutBadGenericMethods(
                                     parameterTypes,
                                     parameterRefKinds,
                                     ImmutableArray.Create<BoundExpression>(methodGroup.ReceiverOpt, new BoundValuePlaceholder(syntax, secondArgumentType) { WasCompilerGenerated = true }),
-                                    ref useSiteInfo); // PROTOTYPE we may need to override ordinals here
+                                    ref useSiteInfo); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : we may need to override ordinals here
 
                                 if (!inferenceResult.Success)
                                 {
@@ -1601,7 +1601,7 @@ static bool bindInvocationExpressionContinued(
                 var methodResult = result.ValidResult;
                 var method = methodResult.Member;
 
-                // PROTOTYPE: It looks like we added a bunch of code in BindInvocationExpressionContinued at this position
+                // Tracked by https://github.com/dotnet/roslyn/issues/76130: It looks like we added a bunch of code in BindInvocationExpressionContinued at this position
                 //            that specifically deals with new extension methods. It adjusts analyzedArguments, etc.
                 //            It is very likely we need to do the same here. 
 
@@ -1663,7 +1663,7 @@ internal static BoundExpression GetUnderlyingCollectionExpressionElement(BoundCo
                         // Add methods. This case can be hit for spreads and non-spread elements.
                         Debug.Assert(call.HasErrors);
                         Debug.Assert(call.Method.Name == "Add");
-                        return call.Arguments[call.InvokedAsExtensionMethod ? 1 : 0]; // PROTOTYPE: Add test coverage for new extensions
+                        return call.Arguments[call.InvokedAsExtensionMethod ? 1 : 0]; // Tracked by https://github.com/dotnet/roslyn/issues/76130: Add test coverage for new extensions
                     case BoundBadExpression badExpression:
                         Debug.Assert(false); // Add test if we hit this assert.
                         return badExpression;
@@ -1712,7 +1712,7 @@ internal bool TryGetCollectionIterationType(SyntaxNode syntax, TypeSymbol collec
                 out iterationType,
                 builder: out var builder);
             // Collection expression target types require instance method GetEnumerator.
-            if (result && builder.ViaExtensionMethod) // PROTOTYPE: Add test coverage for new extensions
+            if (result && builder.ViaExtensionMethod) // Tracked by https://github.com/dotnet/roslyn/issues/76130: Add test coverage for new extensions
             {
                 iterationType = default;
                 return false;

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

@@ -683,7 +683,7 @@ private BoundExpression MakeDeconstructInvocationExpression(
                 // This prevents, for example, an unused params parameter after the out parameters.
                 var deconstructMethod = ((BoundCall)result).Method;
                 var parameters = deconstructMethod.Parameters;
-                for (int i = (deconstructMethod.IsExtensionMethod ? 1 : 0); i < parameters.Length; i++) // PROTOTYPE: Test this code path with new extensions
+                for (int i = (deconstructMethod.IsExtensionMethod ? 1 : 0); i < parameters.Length; i++) // Tracked by https://github.com/dotnet/roslyn/issues/76130: Test this code path with new extensions
                 {
                     if (parameters[i].RefKind != RefKind.Out)
                     {

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

@@ -3905,7 +3905,7 @@ private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument,
             }
             else
             {
-                // PROTOTYPE consider removing or adjusting the reported argument position
+                // Tracked by https://github.com/dotnet/roslyn/issues/76130 : consider removing or adjusting the reported argument position
                 var argNumber = invokedAsExtensionMethod ? arg : arg + 1;
 
                 // Warn for `ref`/`in` or None/`ref readonly` mismatch.
@@ -8016,7 +8016,7 @@ private BoundExpression MakeMemberAccessValue(BoundExpression expr, BindingDiagn
                 Debug.Assert(typeArgumentsOpt.IsDefault);
                 if (!receiver.HasErrors)
                 {
-                    diagnostics.AddRange(resolution.Diagnostics); // PROTOTYPE test dependencies/diagnostics
+                    diagnostics.AddRange(resolution.Diagnostics); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : test dependencies/diagnostics
                 }
 
                 resolution.Free();
@@ -8045,7 +8045,7 @@ private BoundExpression GetExtensionMemberAccess(SyntaxNode syntax, BoundExpress
                     return BindPropertyAccess(syntax, receiver, propertySymbol, diagnostics, LookupResultKind.Viable, hasErrors: false);
 
                 case ExtendedErrorTypeSymbol errorTypeSymbol:
-                    // PROTOTYPE we should likely reduce (ie. do type inference and substitute) the candidates (like ToBadExpression)
+                    // Tracked by https://github.com/dotnet/roslyn/issues/76130 : we should likely reduce (ie. do type inference and substitute) the candidates (like ToBadExpression)
                     return new BoundBadExpression(syntax, LookupResultKind.Viable, errorTypeSymbol.CandidateSymbols!, [receiver], CreateErrorType());
 
                 default:
@@ -8629,7 +8629,7 @@ static bool tryResolveExtensionInScope(
                 // 3. resolve properties
                 Debug.Assert(arity == 0 || lookupResult.Symbols.All(s => s.Kind != SymbolKind.Property));
 
-                // PROTOTYPE: Regarding 'acceptOnlyMethods', consider if it would be better to add a special 'LookupOptions' value to filter out properties during lookup
+                // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Regarding 'acceptOnlyMethods', consider if it would be better to add a special 'LookupOptions' value to filter out properties during lookup
                 OverloadResolutionResult<PropertySymbol>? propertyResult = arity != 0 || acceptOnlyMethods ? null : resolveProperties(left, lookupResult, binder, ref actualReceiverArguments, ref useSiteInfo);
 
                 // 4. determine member kind
@@ -8686,7 +8686,7 @@ static bool tryResolveExtensionInScope(
 
                 // ambiguous between multiple applicable properties
                 propertyResult.Free();
-                // PROTOTYPE consider using the property overload resolution result in the result to improve reported diagnostics
+                // Tracked by https://github.com/dotnet/roslyn/issues/76130 : consider using the property overload resolution result in the result to improve reported diagnostics
                 result = makeErrorResult(left.Type, memberName, arity, lookupResult, expression, diagnostics);
                 return true;
             }
@@ -8816,7 +8816,7 @@ static MethodGroupResolution resolveMethods(
 
             static MethodGroupResolution makeErrorResult(TypeSymbol receiverType, string memberName, int arity, LookupResult lookupResult, SyntaxNode expression, BindingDiagnosticBag diagnostics)
             {
-                // PROTOTYPE we'll want to describe what went wrong in a useful way (see OverloadResolutionResult.ReportDiagnostics)
+                // Tracked by https://github.com/dotnet/roslyn/issues/76130 : we'll want to describe what went wrong in a useful way (see OverloadResolutionResult.ReportDiagnostics)
                 var errorInfo = new CSDiagnosticInfo(ErrorCode.ERR_ExtensionResolutionFailed, receiverType, memberName);
                 diagnostics.Add(errorInfo, expression.Location);
                 var resultSymbol = new ExtendedErrorTypeSymbol(containingSymbol: null, lookupResult.Symbols.ToImmutable(), LookupResultKind.OverloadResolutionFailure, errorInfo, arity);
@@ -10501,7 +10501,7 @@ void makeCall(SyntaxNode syntax, BoundExpression receiver, MethodSymbol method,
                 indexerOrSliceAccess = BindMethodGroupInvocation(syntax, syntax, method.Name, boundMethodGroup, analyzedArguments,
                     diagnostics, queryClause: null, ignoreNormalFormIfHasValidParamsParameter: true, anyApplicableCandidates: out bool _,
                     disallowExpandedNonArrayParams: false,
-                    acceptOnlyMethods: true).MakeCompilerGenerated(); // PROTOTYPE: Test effect of acceptOnlyMethods value
+                    acceptOnlyMethods: true).MakeCompilerGenerated(); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Test effect of acceptOnlyMethods value
 
                 analyzedArguments.Free();
             }
@@ -10630,7 +10630,7 @@ internal MethodGroupResolution ResolveMethodGroup(
             return ResolveMethodGroup(
                 node, node.Syntax, node.Name, analyzedArguments, ref useSiteInfo,
                 options,
-                acceptOnlyMethods: true, // PROTOTYPE: Confirm this value is appropriate for all consumers of the enclosing method and test effect of this value for all of them
+                acceptOnlyMethods: true, // Tracked by https://github.com/dotnet/roslyn/issues/76130 : Confirm this value is appropriate for all consumers of the enclosing method and test effect of this value for all of them
                 returnRefKind: returnRefKind, returnType: returnType,
                 callingConventionInfo: callingConventionInfo);
         }

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

@@ -2398,7 +2398,7 @@ internal bool InvocableNameofInScope()
 #nullable enable
         private BoundFunctionPointerInvocation BindFunctionPointerInvocation(SyntaxNode node, BoundExpression boundExpression, AnalyzedArguments analyzedArguments, BindingDiagnosticBag diagnostics)
         {
-            // PROTOTYPE this function will probably need an adjustment to deal with static extensions 
+            // Tracked by https://github.com/dotnet/roslyn/issues/76130 : this function will probably need an adjustment to deal with static extensions 
             boundExpression = BindToNaturalType(boundExpression, diagnostics);
             RoslynDebug.Assert(boundExpression.Type is FunctionPointerTypeSymbol);
 

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

@@ -523,7 +523,7 @@ private static void LookupMembersInNamespace(LookupResult result, NamespaceSymbo
             }
         }
 
-        // PROTOTYPE we should be able to remove this method once all the callers are updated to account for new extension members
+        // Tracked by https://github.com/dotnet/roslyn/issues/76130 : we should be able to remove this method once all the callers are updated to account for new extension members
         /// <summary>
         /// Lookup extension methods by name and arity in the given binder and
         /// check viability in this binder. The lookup is performed on a single

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

@@ -1058,7 +1058,7 @@ deconstructMethod is null &&
             if (deconstructMethod is null)
                 hasErrors = true;
 
-            int skippedExtensionParameters = deconstructMethod?.IsExtensionMethod == true ? 1 : 0; // PROTOTYPE: Test this code path with new extensions
+            int skippedExtensionParameters = deconstructMethod?.IsExtensionMethod == true ? 1 : 0; // Tracked by https://github.com/dotnet/roslyn/issues/76130: Test this code path with new extensions
             for (int i = 0; i < node.Subpatterns.Count; i++)
             {
                 var subPattern = node.Subpatterns[i];

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

@@ -676,7 +676,7 @@ private void ReduceFrom(FromClauseSyntax from, QueryTranslationState state, Bind
 
         private static BoundExpression? ExtractCastInvocation(BoundCall invocation)
         {
-            int index = invocation.InvokedAsExtensionMethod ? 1 : 0; // PROTOTYPE: Add test coverage for his code path
+            int index = invocation.InvokedAsExtensionMethod ? 1 : 0; // Tracked by https://github.com/dotnet/roslyn/issues/76130: Add test coverage for his code path
             var c1 = invocation.Arguments[index] as BoundConversion;
             var l1 = c1 != null ? c1.Operand as BoundLambda : null;
             var r1 = l1 != null ? l1.Body.Statements[0] as BoundReturnStatement : null;

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

@@ -215,7 +215,7 @@ private static bool ReportQueryInferenceFailedSelectMany(FromClauseSyntax fromCl
             Debug.Assert(methodName == "SelectMany");
 
             // Estimate the return type of Select's lambda argument
-            BoundExpression arg = arguments.Argument(arguments.IncludesReceiverAsArgument ? 1 : 0); // PROTOTYPE test this code path for new extensions
+            BoundExpression arg = arguments.Argument(arguments.IncludesReceiverAsArgument ? 1 : 0); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : test this code path for new extensions
             TypeSymbol type = null;
             if (arg.Kind == BoundKind.UnboundLambda)
             {

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

@@ -1545,7 +1545,7 @@ private void CheckWhatCandidatesWeHave(
                 foreach (var scope in new ExtensionScopes(this))
                 {
                     lookupResult ??= LookupResult.GetInstance();
-                    LookupExtensionMethods(lookupResult, scope, plainName, arity, ref useSiteInfo); // PROTOTYPE account for new extension members
+                    LookupExtensionMethods(lookupResult, scope, plainName, arity, ref useSiteInfo); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : account for new extension members
 
                     if (lookupResult.IsMultiViable)
                     {