Extensions: Review/adjust call sites of MethodSymbol.IsExtensionMethod API (#77820)

AlekseyTs · web-flow · commit c9365089ba38 · 2025-03-26T06:29:06.000-07:00
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -1708,7 +1708,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)
+            if (result && builder.ViaExtensionMethod) // PROTOTYPE: Add test coverage for new extensions
             {
                 iterationType = default;
                 return false;
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Deconstruct.cs b/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++)
+                for (int i = (deconstructMethod.IsExtensionMethod ? 1 : 0); i < parameters.Length; i++) // PROTOTYPE: Test this code path with new extensions
                 {
                     if (parameters[i].RefKind != RefKind.Out)
                     {
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs b/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;
+            int skippedExtensionParameters = deconstructMethod?.IsExtensionMethod == true ? 1 : 0; // PROTOTYPE: Test this code path with new extensions
             for (int i = 0; i < node.Subpatterns.Count; i++)
             {
                 var subPattern = node.Subpatterns[i];
diff --git a/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs b/src/Compilers/CSharp/Portable/Binder/ForEachLoopBinder.cs
@@ -236,12 +236,20 @@ private BoundForEachStatement BindForEachPartsWorker(BindingDiagnosticBag diagno
             {
                 originalBinder.CheckImplicitThisCopyInReadOnlyMember(collectionExpr, getEnumeratorMethod, diagnostics);
 
-                if (getEnumeratorMethod.IsExtensionMethod && !hasErrors)
+                if (!hasErrors)
                 {
-                    var messageId = IsAsync ? MessageID.IDS_FeatureExtensionGetAsyncEnumerator : MessageID.IDS_FeatureExtensionGetEnumerator;
-                    messageId.CheckFeatureAvailability(diagnostics, Compilation, collectionExpr.Syntax.Location);
+                    if (getEnumeratorMethod.IsExtensionMethod)
+                    {
+                        var messageId = IsAsync ? MessageID.IDS_FeatureExtensionGetAsyncEnumerator : MessageID.IDS_FeatureExtensionGetEnumerator;
+                        messageId.CheckFeatureAvailability(diagnostics, Compilation, collectionExpr.Syntax.Location);
 
-                    if (getEnumeratorMethod.ParameterRefKinds is { IsDefault: false } refKinds && refKinds[0] == RefKind.Ref)
+                        if (getEnumeratorMethod.ParameterRefKinds is { IsDefault: false } refKinds && refKinds[0] == RefKind.Ref)
+                        {
+                            Error(diagnostics, ErrorCode.ERR_RefLvalueExpected, collectionExpr.Syntax);
+                            hasErrors = true;
+                        }
+                    }
+                    else if (getEnumeratorMethod.GetIsNewExtensionMember() && getEnumeratorMethod.ContainingType.ExtensionParameter.RefKind == RefKind.Ref) // PROTOTYPE: add test coverage for 'ref readonly' and 'in' 
                     {
                         Error(diagnostics, ErrorCode.ERR_RefLvalueExpected, collectionExpr.Syntax);
                         hasErrors = true;
@@ -570,7 +578,8 @@ private BoundForEachStatement BindForEachPartsWorker(BindingDiagnosticBag diagno
                 (collectionConversionClassification.IsImplicit &&
                  (IsIEnumerable(builder.CollectionType) ||
                   IsIEnumerableT(builder.CollectionType.OriginalDefinition, IsAsync, Compilation) ||
-                  builder.GetEnumeratorInfo.Method.IsExtensionMethod)) ||
+                  builder.GetEnumeratorInfo.Method.IsExtensionMethod ||
+                  builder.GetEnumeratorInfo.Method.GetIsNewExtensionMember())) ||
                 // For compat behavior, we can enumerate over System.String even if it's not IEnumerable. That will
                 // result in an explicit reference conversion in the bound nodes, but that conversion won't be emitted.
                 (collectionConversionClassification.Kind == ConversionKind.ExplicitReference && collectionExpr.Type.SpecialType == SpecialType.System_String));
@@ -861,9 +870,9 @@ private EnumeratorResult GetEnumeratorInfoCore(SyntaxNode syntax, SyntaxNode col
 
 #if DEBUG
                 Debug.Assert(span == originalSpan);
-                Debug.Assert(!builder.ViaExtensionMethod || builder.GetEnumeratorInfo.Method.IsExtensionMethod);
+                Debug.Assert(!builder.ViaExtensionMethod || builder.GetEnumeratorInfo.Method.IsExtensionMethod || builder.GetEnumeratorInfo.Method.GetIsNewExtensionMember());
 #endif
-                if (!builder.ViaExtensionMethod &&
+                if (!builder.ViaExtensionMethod && // PROTOTYPE: Add test coverage for new extensions
                     ((result is EnumeratorResult.Succeeded && builder.ElementTypeWithAnnotations.Equals(elementField.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions) &&
                       builder.CurrentPropertyGetter?.RefKind == (wellKnownSpan == WellKnownType.System_ReadOnlySpan_T ? RefKind.RefReadOnly : RefKind.Ref)) ||
                      result is EnumeratorResult.FailedAndReported))
@@ -908,7 +917,7 @@ private EnumeratorResult GetEnumeratorInfoCore(SyntaxNode syntax, SyntaxNode col
 #if DEBUG
             Debug.Assert(collectionExpr == originalCollectionExpr ||
                          (originalCollectionExpr.Type?.IsNullableType() == true && originalCollectionExpr.Type.StrippedType().Equals(collectionExpr.Type, TypeCompareKind.AllIgnoreOptions)));
-            Debug.Assert(!builder.ViaExtensionMethod || builder.GetEnumeratorInfo.Method.IsExtensionMethod);
+            Debug.Assert(!builder.ViaExtensionMethod || builder.GetEnumeratorInfo.Method.IsExtensionMethod || builder.GetEnumeratorInfo.Method.GetIsNewExtensionMember());
 #endif
 
             return result;
@@ -1019,12 +1028,26 @@ EnumeratorResult createPatternBasedEnumeratorResult(ref ForEachEnumeratorInfo.Bu
             {
                 Debug.Assert((object)builder.GetEnumeratorInfo != null);
 
-                Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty));
+                Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.IsExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty));
+                Debug.Assert(!(viaExtensionMethod && !builder.GetEnumeratorInfo.Method.IsExtensionMethod && !builder.GetEnumeratorInfo.Method.GetIsNewExtensionMember()));
 
                 builder.ViaExtensionMethod = viaExtensionMethod;
-                builder.CollectionType = viaExtensionMethod
-                    ? builder.GetEnumeratorInfo.Method.Parameters[0].Type
-                    : collectionExpr.Type;
+
+                if (viaExtensionMethod)
+                {
+                    if (builder.GetEnumeratorInfo.Method.IsExtensionMethod)
+                    {
+                        builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type;
+                    }
+                    else
+                    {
+                        builder.CollectionType = builder.GetEnumeratorInfo.Method.ContainingType.ExtensionParameter.Type;
+                    }
+                }
+                else
+                {
+                    builder.CollectionType = collectionExpr.Type;
+                }
 
                 if (SatisfiesForEachPattern(syntax, collectionSyntax, ref builder, isAsync, diagnostics))
                 {
@@ -1200,7 +1223,7 @@ private void GetDisposalInfoForEnumerator(SyntaxNode syntax, ref ForEachEnumerat
                 MethodSymbol patternDisposeMethod = TryFindDisposePatternMethod(receiver, syntax, isAsync, patternDiagnostics, out bool expanded);
                 if (patternDisposeMethod is object)
                 {
-                    Debug.Assert(!patternDisposeMethod.IsExtensionMethod);
+                    Debug.Assert(!patternDisposeMethod.IsExtensionMethod && !patternDisposeMethod.GetIsNewExtensionMember());
                     Debug.Assert(patternDisposeMethod.ParameterRefKinds.IsDefaultOrEmpty ||
                         patternDisposeMethod.ParameterRefKinds.All(static refKind => refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));
 
@@ -1522,6 +1545,8 @@ private MethodArgumentInfo FindForEachPatternMethodViaExtension(SyntaxNode synta
             {
                 var result = overloadResolutionResult.ValidResult.Member;
 
+                Debug.Assert(result.IsExtensionMethod || result.GetIsNewExtensionMember());
+
                 if (result.CallsAreOmitted(syntax.SyntaxTree))
                 {
                     // Calls to this method are omitted in the current syntax tree, i.e it is either a partial method with no implementation part OR a conditional method whose condition is not true in this source file.
@@ -1531,28 +1556,44 @@ private MethodArgumentInfo FindForEachPatternMethodViaExtension(SyntaxNode synta
                     return null;
                 }
 
-                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
-                diagnostics.Add(syntax, useSiteInfo);
+                MethodArgumentInfo info;
+                bool expanded = overloadResolutionResult.ValidResult.Result.Kind == MemberResolutionKind.ApplicableInExpandedForm;
 
-                // Unconditionally convert here, to match what we set the ConvertedExpression to in the main BoundForEachStatement node.
-                Debug.Assert(!collectionConversion.IsUserDefined);
-                collectionExpr = new BoundConversion(
-                    collectionExpr.Syntax,
-                    collectionExpr,
-                    collectionConversion,
-                    @checked: CheckOverflowAtRuntime,
-                    explicitCastInCode: false,
-                    conversionGroupOpt: null,
-                    ConstantValue.NotAvailable,
-                    result.Parameters[0].Type);
+                if (result.IsExtensionMethod)
+                {
+                    CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+                    var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);
+                    diagnostics.Add(syntax, useSiteInfo);
+
+                    // Unconditionally convert here, to match what we set the ConvertedExpression to in the main BoundForEachStatement node.
+                    Debug.Assert(!collectionConversion.IsUserDefined);
+                    collectionExpr = new BoundConversion(
+                        collectionExpr.Syntax,
+                        collectionExpr,
+                        collectionConversion,
+                        @checked: CheckOverflowAtRuntime,
+                        explicitCastInCode: false,
+                        conversionGroupOpt: null,
+                        ConstantValue.NotAvailable,
+                        result.Parameters[0].Type);
+
+                    info = BindDefaultArguments(
+                        result,
+                        collectionExpr,
+                        expanded: expanded,
+                        collectionExpr.Syntax,
+                        diagnostics);
+                }
+                else
+                {
+                    info = BindDefaultArguments(
+                        result,
+                        extensionReceiverOpt: null,
+                        expanded: expanded,
+                        collectionExpr.Syntax,
+                        diagnostics);
+                }
 
-                var info = BindDefaultArguments(
-                    result,
-                    collectionExpr,
-                    expanded: overloadResolutionResult.ValidResult.Result.Kind == MemberResolutionKind.ApplicableInExpandedForm,
-                    collectionExpr.Syntax,
-                    diagnostics);
                 methodGroupResolutionResult.Free();
                 analyzedArguments.Free();
                 return info;
diff --git a/src/Compilers/CSharp/Portable/Binder/RefSafetyAnalysis.cs b/src/Compilers/CSharp/Portable/Binder/RefSafetyAnalysis.cs
@@ -604,7 +604,7 @@ static SafeContext getDeclarationValEscape(BoundTypeExpression typeExpression, S
 
             static ParameterSymbol? tryGetThisParameter(MethodSymbol method)
             {
-                if (method.IsExtensionMethod)
+                if (method.IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions
                 {
                     return method.Parameters is [{ } firstParameter, ..] ? firstParameter : null;
                 }
diff --git a/src/Compilers/CSharp/Portable/Binder/WithUsingNamespacesAndTypesBinder.cs b/src/Compilers/CSharp/Portable/Binder/WithUsingNamespacesAndTypesBinder.cs
@@ -195,7 +195,7 @@ private static bool IsValidLookupCandidateInUsings(Symbol symbol)
 
                 // lookup via "using static" ignores extension methods and non-static methods
                 case SymbolKind.Method:
-                    if (!symbol.IsStatic || ((MethodSymbol)symbol).IsExtensionMethod)
+                    if (!symbol.IsStatic || ((MethodSymbol)symbol).IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions
                     {
                         return false;
                     }
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
@@ -1642,7 +1642,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE
             static bool ignoreReceiver(MethodSymbol method)
             {
                 // static methods that aren't extensions get an implicit `this` receiver that should be ignored
-                return method.IsStatic && !method.IsExtensionMethod;
+                return method.IsStatic && !method.IsExtensionMethod; // PROTOTYPE: Test this code path with new extensions
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.DebugVerifier.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.DebugVerifier.cs
@@ -231,7 +231,7 @@ private void VerifyExpression(BoundExpression expression, bool overrideSkippedEx
             private void VisitForEachEnumeratorInfo(ForEachEnumeratorInfo enumeratorInfo)
             {
                 Visit(enumeratorInfo.DisposeAwaitableInfo);
-                if (enumeratorInfo.GetEnumeratorInfo.Method.IsExtensionMethod)
+                if (enumeratorInfo.GetEnumeratorInfo.Method.IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions
                 {
                     foreach (var arg in enumeratorInfo.GetEnumeratorInfo.Arguments)
                     {
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -11042,7 +11042,7 @@ private void VisitForEachExpression(
 
             MethodSymbol? reinferredGetEnumeratorMethod = null;
 
-            if (enumeratorInfoOpt?.GetEnumeratorInfo is { Method: { IsExtensionMethod: true, Parameters: var parameters } } enumeratorMethodInfo)
+            if (enumeratorInfoOpt?.GetEnumeratorInfo is { Method: { IsExtensionMethod: true, Parameters: var parameters } } enumeratorMethodInfo) // PROTOTYPE: Test this code path with new extensions
             {
                 // this is case 7
                 // We do not need to do this same analysis for non-extension methods because they do not have generic parameters that
@@ -11109,7 +11109,7 @@ private void VisitForEachExpression(
                 useLegacyWarnings: false,
                 AssignmentKind.Assignment);
 
-            bool reportedDiagnostic = enumeratorInfoOpt?.GetEnumeratorInfo.Method is { IsExtensionMethod: true }
+            bool reportedDiagnostic = enumeratorInfoOpt?.GetEnumeratorInfo.Method is { IsExtensionMethod: true } // PROTOTYPE: Test this code path with new extensions
                 ? false
                 : CheckPossibleNullReceiver(expr);
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.PatternLocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.PatternLocalRewriter.cs
@@ -169,7 +169,7 @@ void addArg(RefKind refKind, BoundExpression expression)
 
                             Debug.Assert(method.Name == WellKnownMemberNames.DeconstructMethodName);
                             int extensionExtra;
-                            if (method.IsStatic)
+                            if (method.IsStatic) // PROTOTYPE: Test this code path with new extensions
                             {
                                 Debug.Assert(method.IsExtensionMethod);
                                 receiver = _factory.Type(method.ContainingType);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -199,7 +199,7 @@ private void InterceptCallAndAdjustArguments(
             // When the original call is to an instance method, and the interceptor is an extension method,
             // we need to take special care to intercept with the extension method as though it is being called in reduced form.
             Debug.Assert(receiverOpt is not BoundTypeExpression || method.IsStatic);
-            var needToReduce = receiverOpt is not (null or BoundTypeExpression) && interceptor.IsExtensionMethod;
+            var needToReduce = receiverOpt is not (null or BoundTypeExpression) && interceptor.IsExtensionMethod; // PROTOTYPE: Test this code path with new extensions
             var symbolForCompare = needToReduce ? ReducedExtensionMethodSymbol.Create(interceptor, receiverOpt!.Type, _compilation, out _) : interceptor; // PROTOTYPE test interceptors
 
             if (!MemberSignatureComparer.InterceptorsComparer.Equals(method, symbolForCompare))
@@ -245,7 +245,7 @@ private void InterceptCallAndAdjustArguments(
                     break;
             }
 
-            if (invokedAsExtensionMethod && interceptor.IsStatic && !interceptor.IsExtensionMethod)
+            if (invokedAsExtensionMethod && interceptor.IsStatic && !interceptor.IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions
             {
                 // Special case when intercepting an extension method call in reduced form with a non-extension.
                 this._diagnostics.Add(ErrorCode.ERR_InterceptorMustHaveMatchingThisParameter, attributeLocation, method.Parameters[0], method);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ForEachStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ForEachStatement.cs
@@ -181,7 +181,7 @@ private BoundStatement RewriteForEachEnumerator(
 
             // ((C)(x)).GetEnumerator();  OR  (x).GetEnumerator();  OR  async variants (which fill-in arguments for optional parameters)
             BoundExpression enumeratorVarInitValue = SynthesizeCall(getEnumeratorInfo, forEachSyntax, receiver,
-                allowExtensionAndOptionalParameters: isAsync || getEnumeratorInfo.Method.IsExtensionMethod, firstRewrittenArgument: firstRewrittenArgument);
+                allowExtensionAndOptionalParameters: isAsync || getEnumeratorInfo.Method.IsExtensionMethod || getEnumeratorInfo.Method.GetIsNewExtensionMember(), firstRewrittenArgument: firstRewrittenArgument);
 
             // E e = ((C)(x)).GetEnumerator();
             BoundStatement enumeratorVarDecl = MakeLocalDeclaration(forEachSyntax, enumeratorVar, enumeratorVarInitValue);
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs
@@ -1588,9 +1588,8 @@ void validateParamsType(BindingDiagnosticBag diagnostics)
 
                             Debug.Assert(!addMethods.IsDefaultOrEmpty);
 
-                            if (addMethods[0].IsStatic) // No need to check other methods, extensions are never mixed with instance methods
+                            if (addMethods[0].IsExtensionMethod || addMethods[0].GetIsNewExtensionMember()) // No need to check other methods, extensions are never mixed with instance methods
                             {
-                                Debug.Assert(addMethods[0].IsExtensionMethod);
                                 diagnostics.Add(ErrorCode.ERR_ParamsCollectionExtensionAddMethod, syntax, Type);
                                 return;
                             }
diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1708,7 +1708,7 @@ internal bool TryGetCollectionIterationType(SyntaxNode syntax, TypeSymbol collec`
`1708`	`1708`	`out iterationType,`
`1709`	`1709`	`builder: out var builder);`
`1710`	`1710`	`// Collection expression target types require instance method GetEnumerator.`
`1711`		`- if (result && builder.ViaExtensionMethod)`
	`1711`	`+ if (result && builder.ViaExtensionMethod) // PROTOTYPE: Add test coverage for new extensions`
`1712`	`1712`	`{`
`1713`	`1713`	`iterationType = default;`
`1714`	`1714`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -683,7 +683,7 @@ private BoundExpression MakeDeconstructInvocationExpression(`
`683`	`683`	`// This prevents, for example, an unused params parameter after the out parameters.`
`684`	`684`	`var deconstructMethod = ((BoundCall)result).Method;`
`685`	`685`	`var parameters = deconstructMethod.Parameters;`
`686`		`- for (int i = (deconstructMethod.IsExtensionMethod ? 1 : 0); i < parameters.Length; i++)`
	`686`	`+ for (int i = (deconstructMethod.IsExtensionMethod ? 1 : 0); i < parameters.Length; i++) // PROTOTYPE: Test this code path with new extensions`
`687`	`687`	`{`
`688`	`688`	`if (parameters[i].RefKind != RefKind.Out)`
`689`	`689`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1058,7 +1058,7 @@ deconstructMethod is null &&`
`1058`	`1058`	`if (deconstructMethod is null)`
`1059`	`1059`	`hasErrors = true;`
`1060`	`1060`
`1061`		`- int skippedExtensionParameters = deconstructMethod?.IsExtensionMethod == true ? 1 : 0;`
	`1061`	`+ int skippedExtensionParameters = deconstructMethod?.IsExtensionMethod == true ? 1 : 0; // PROTOTYPE: Test this code path with new extensions`
`1062`	`1062`	`for (int i = 0; i < node.Subpatterns.Count; i++)`
`1063`	`1063`	`{`
`1064`	`1064`	`var subPattern = node.Subpatterns[i];`
Original file line number	Diff line number	Diff line change
`@@ -604,7 +604,7 @@ static SafeContext getDeclarationValEscape(BoundTypeExpression typeExpression, S`
`604`	`604`
`605`	`605`	`static ParameterSymbol? tryGetThisParameter(MethodSymbol method)`
`606`	`606`	`{`
`607`		`- if (method.IsExtensionMethod)`
	`607`	`+ if (method.IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions`
`608`	`608`	`{`
`609`	`609`	`return method.Parameters is [{ } firstParameter, ..] ? firstParameter : null;`
`610`	`610`	`}`
Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,7 @@ private static bool IsValidLookupCandidateInUsings(Symbol symbol)`
`195`	`195`
`196`	`196`	`// lookup via "using static" ignores extension methods and non-static methods`
`197`	`197`	`case SymbolKind.Method:`
`198`		`- if (!symbol.IsStatic \|\| ((MethodSymbol)symbol).IsExtensionMethod)`
	`198`	`+ if (!symbol.IsStatic \|\| ((MethodSymbol)symbol).IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions`
`199`	`199`	`{`
`200`	`200`	`return false;`
`201`	`201`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1642,7 +1642,7 @@ public override BoundNode VisitDelegateCreationExpression(BoundDelegateCreationE`
`1642`	`1642`	`static bool ignoreReceiver(MethodSymbol method)`
`1643`	`1643`	`{`
`1644`	`1644`	// static methods that aren't extensions get an implicit `this` receiver that should be ignored
`1645`		`- return method.IsStatic && !method.IsExtensionMethod;`
	`1645`	`+ return method.IsStatic && !method.IsExtensionMethod; // PROTOTYPE: Test this code path with new extensions`
`1646`	`1646`	`}`
`1647`	`1647`	`}`
`1648`	`1648`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ private void VerifyExpression(BoundExpression expression, bool overrideSkippedEx`
`231`	`231`	`private void VisitForEachEnumeratorInfo(ForEachEnumeratorInfo enumeratorInfo)`
`232`	`232`	`{`
`233`	`233`	`Visit(enumeratorInfo.DisposeAwaitableInfo);`
`234`		`- if (enumeratorInfo.GetEnumeratorInfo.Method.IsExtensionMethod)`
	`234`	`+ if (enumeratorInfo.GetEnumeratorInfo.Method.IsExtensionMethod) // PROTOTYPE: Test this code path with new extensions`
`235`	`235`	`{`
`236`	`236`	`foreach (var arg in enumeratorInfo.GetEnumeratorInfo.Arguments)`
`237`	`237`	`{`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ void addArg(RefKind refKind, BoundExpression expression)`
`169`	`169`
`170`	`170`	`Debug.Assert(method.Name == WellKnownMemberNames.DeconstructMethodName);`
`171`	`171`	`int extensionExtra;`
`172`		`- if (method.IsStatic)`
	`172`	`+ if (method.IsStatic) // PROTOTYPE: Test this code path with new extensions`
`173`	`173`	`{`
`174`	`174`	`Debug.Assert(method.IsExtensionMethod);`
`175`	`175`	`receiver = _factory.Type(method.ContainingType);`