Extensions: relax inferrability rule

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -8135,7 +8135,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>'value': an automatically-generated parameter name conflicts with an extension type parameter name</value>
   </data>
   <data name="ERR_UnderspecifiedExtension" xml:space="preserve">
-    <value>The extended type '{0}' must reference all the type parameters declared by the extension, but type parameter '{1}' is not referenced.</value>
+    <value>Every type parameter from the extension block must be referenced by the extension parameter or a parameter of this member. But type parameter `{0}` is not referenced.</value>
   </data>
   <data name="ERR_ExpressionTreeContainsExtensionPropertyAccess" xml:space="preserve">
     <value>An expression tree may not contain an extension property access</value>

src/Compilers/CSharp/Portable/Symbols/Extensions/SynthesizedExtensionMarker.cs

@@ -77,8 +77,6 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
 
                 if (parameter is { })
                 {
-                    checkUnderspecifiedGenericExtension(parameter, ContainingType.TypeParameters, diagnostics);
-
                     TypeSymbol parameterType = parameter.TypeWithAnnotations.Type;
                     RefKind parameterRefKind = parameter.RefKind;
                     SyntaxNode? parameterTypeSyntax = parameterList.Parameters[0].Type;
@@ -112,34 +110,6 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
 
                 return parameter;
             }
-
-            static void checkUnderspecifiedGenericExtension(ParameterSymbol parameter, ImmutableArray<TypeParameterSymbol> typeParameters, BindingDiagnosticBag diagnostics)
-            {
-                var underlyingType = parameter.Type;
-                var usedTypeParameters = PooledHashSet<TypeParameterSymbol>.GetInstance();
-                underlyingType.VisitType(collectTypeParameters, arg: usedTypeParameters);
-
-                foreach (var typeParameter in typeParameters)
-                {
-                    if (!usedTypeParameters.Contains(typeParameter))
-                    {
-                        diagnostics.Add(ErrorCode.ERR_UnderspecifiedExtension, parameter.GetFirstLocation(), underlyingType, typeParameter);
-                    }
-                }
-
-                usedTypeParameters.Free();
-            }
-
-            static bool collectTypeParameters(TypeSymbol type, PooledHashSet<TypeParameterSymbol> typeParameters, bool ignored)
-            {
-                if (type is TypeParameterSymbol typeParameter)
-                {
-                    typeParameters.Add(typeParameter);
-                }
-
-                return false;
-            }
-
         }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs

@@ -519,6 +519,44 @@ private static void EnsureNullableAttributeExists(CSharpCompilation compilation,
             }
         }
 
+        internal static void CheckUnderspecifiedGenericExtension(Symbol extensionMember, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics)
+        {
+            Debug.Assert(extensionMember.GetIsNewExtensionMember());
+
+            NamedTypeSymbol extension = extensionMember.ContainingType;
+            if (extension.ExtensionParameter is not { } extensionParameter)
+            {
+                return;
+            }
+
+            var usedTypeParameters = PooledHashSet<TypeParameterSymbol>.GetInstance();
+            extensionParameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters);
+            foreach (var parameter in parameters)
+            {
+                parameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters);
+            }
+
+            foreach (var typeParameter in extension.TypeParameters)
+            {
+                if (!usedTypeParameters.Contains(typeParameter))
+                {
+                    diagnostics.Add(ErrorCode.ERR_UnderspecifiedExtension, extensionMember.GetFirstLocation(), typeParameter);
+                }
+            }
+
+            usedTypeParameters.Free();
+
+            static bool collectTypeParameters(TypeSymbol type, PooledHashSet<TypeParameterSymbol> typeParameters, bool ignored)
+            {
+                if (type is TypeParameterSymbol typeParameter)
+                {
+                    typeParameters.Add(typeParameter);
+                }
+
+                return false;
+            }
+        }
+
         internal static Location GetParameterLocation(ParameterSymbol parameter) => parameter.GetNonNullSyntaxNode().Location;
 
         internal static void CheckParameterModifiers(

src/Compilers/CSharp/Portable/Symbols/Source/SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs

@@ -263,6 +263,11 @@ internal override void AfterAddingTypeMembersChecks(ConversionsBase conversions,
 
             ParameterHelpers.EnsureNullableAttributeExists(compilation, this, Parameters, diagnostics, modifyCompilation: true);
 
+            if (this.GetIsNewExtensionMember() && MethodKind != MethodKind.Ordinary)
+            {
+                ParameterHelpers.CheckUnderspecifiedGenericExtension(this, Parameters, diagnostics);
+            }
+
             Location getReturnTypeLocation()
             {
                 returnTypeLocation ??= this.ReturnTypeLocation;

src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs

@@ -1061,6 +1061,11 @@ internal override void AfterAddingTypeMembersChecks(ConversionsBase conversions,
             }
 
             ParameterHelpers.EnsureNullableAttributeExists(compilation, this, Parameters, diagnostics, modifyCompilation: true);
+
+            if (this.GetIsNewExtensionMember())
+            {
+                ParameterHelpers.CheckUnderspecifiedGenericExtension(this, Parameters, diagnostics);
+            }
         }
 
         private void CheckAccessibility(Location location, BindingDiagnosticBag diagnostics, bool isExplicitInterfaceImplementation)