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,71 @@ 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 || extension.ContainingType.Arity != 0)
+            {
+                // error cases, already reported elsewhere
+                return;
+            }
+
+            if (extension.Arity == 0)
+            {
+                return;
+            }
+
+            var usedTypeParameters = PooledHashSet<TypeParameterSymbol>.GetInstance();
+            reportUnusedExtensionTypeParameters(extensionMember, parameters, diagnostics, extension, extensionParameter, usedTypeParameters);
+
+            usedTypeParameters.Free();
+            return;
+
+            static void reportUnusedExtensionTypeParameters(Symbol extensionMember, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics, NamedTypeSymbol extension, ParameterSymbol extensionParameter, PooledHashSet<TypeParameterSymbol> usedTypeParameters)
+            {
+                int extensionArity = extension.Arity;
+                int extensionMemberArity = extensionMember.GetMemberArity();
+                Debug.Assert(extensionMemberArity == 0); // we currently only apply the check for members which may not be generic
+
+                extensionParameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters);
+
+                if (usedTypeParameters.Count == extensionArity && extensionMemberArity == 0)
+                {
+                    return;
+                }
+
+                foreach (var parameter in parameters)
+                {
+                    parameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters);
+
+                    if (usedTypeParameters.Count == extensionArity && extensionMemberArity == 0)
+                    {
+                        return;
+                    }
+                }
+
+                foreach (var typeParameter in extension.TypeParameters)
+                {
+                    if (!usedTypeParameters.Contains(typeParameter))
+                    {
+                        diagnostics.Add(ErrorCode.ERR_UnderspecifiedExtension, extensionMember.GetFirstLocation(), typeParameter);
+                    }
+                }
+            }
+
+            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)

src/Compilers/CSharp/Portable/Symbols/TypeSymbol.cs

@@ -561,6 +561,7 @@ public bool IsExtension
 
         /// <summary>
         /// For the type representing an extension declaration, returns the receiver parameter symbol.
+        /// Note: this may be null even if <see cref="IsExtension"/> is true, in error cases.
         /// </summary>
         internal abstract ParameterSymbol? ExtensionParameter { get; }
 #nullable disable