Extensions: relax inferrability rule for methods

Author: Julien Couvreur

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>The extended type '{0}' must reference all the type parameters declared by the extension, since the extension block contains a non-method member, but type parameter '{1}' 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/SourceNamedTypeSymbol.cs

@@ -1986,6 +1986,45 @@ protected override void AfterMembersCompletedChecks(BindingDiagnosticBag diagnos
                     var syntax = (ExtensionBlockDeclarationSyntax)this.GetNonNullSyntaxNode();
                     diagnostics.Add(ErrorCode.ERR_BadExtensionContainingType, syntax.Keyword);
                 }
+
+                if (TryGetOrCreateExtensionMarker() is { Parameters: [var extensionParameter] })
+                {
+                    checkUnderspecifiedGenericExtension(extensionParameter, TypeParameters, diagnostics);
+                }
+            }
+
+            return;
+
+            void checkUnderspecifiedGenericExtension(ParameterSymbol parameter, ImmutableArray<TypeParameterSymbol> typeParameters, BindingDiagnosticBag diagnostics)
+            {
+                if (GetMembers().All((m, a) => m is MethodSymbol { MethodKind: MethodKind.Ordinary }, arg: (object?)null))
+                {
+                    return;
+                }
+
+                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;
             }
         }
     }