Extensions: check inferrability

Author: jcouv

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

@@ -7854,7 +7854,7 @@ BoundExpression tryBindMemberAccessWithBoundNamespaceLeft(
                     Error(diagnostics, lookupResult.Error, right);
 
                     return new BoundTypeExpression(node, null,
-                                new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(symbols[0]), symbols.ToImmutable(), lookupResult.Kind, lookupResult.Error, rightArity));
+                                new ExtendedErrorTypeSymbol(GetContainingNamespaceOrNonExtensionType(symbols[0]), symbols.ToImmutable(), lookupResult.Kind, lookupResult.Error, rightArity));
                 }
                 else if (lookupResult.Kind == LookupResultKind.Empty)
                 {

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

@@ -338,16 +338,24 @@ internal NamespaceOrTypeOrAliasSymbolWithAnnotations BindTypeOrAlias(ExpressionS
             }
 
             var diagnosticInfo = diagnostics.Add(ErrorCode.ERR_BadSKknown, syntax.Location, syntax, symbol.Symbol.GetKindText(), MessageID.IDS_SK_TYPE.Localize());
-            return TypeWithAnnotations.Create(new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(symbol.Symbol), symbol.Symbol, LookupResultKind.NotATypeOrNamespace, diagnosticInfo));
+            return TypeWithAnnotations.Create(new ExtendedErrorTypeSymbol(GetContainingNamespaceOrNonExtensionType(symbol.Symbol), symbol.Symbol, LookupResultKind.NotATypeOrNamespace, diagnosticInfo));
         }
 
         /// <summary>
         /// The immediately containing namespace or named type, or the global
         /// namespace if containing symbol is neither a namespace or named type.
+        /// We don't want to use an extension declaration as the containing type
+        /// for error type symbols, as that causes cycles.
         /// </summary>
-        private NamespaceOrTypeSymbol GetContainingNamespaceOrType(Symbol symbol)
+        private NamespaceOrTypeSymbol GetContainingNamespaceOrNonExtensionType(Symbol symbol)
         {
-            return symbol.ContainingNamespaceOrType() ?? this.Compilation.Assembly.GlobalNamespace;
+            if (symbol.ContainingNamespaceOrType() is { } containing
+                && containing is not TypeSymbol { IsExtension: true })
+            {
+                return containing;
+            }
+
+            return this.Compilation.Assembly.GlobalNamespace;
         }
 
         internal Symbol BindNamespaceAliasSymbol(IdentifierNameSyntax node, BindingDiagnosticBag diagnostics)
@@ -1305,7 +1313,7 @@ private NamedTypeSymbol LookupGenericTypeName(
                 // for us.
                 Debug.Assert(lookupResult.Error != null);
                 type = new ExtendedErrorTypeSymbol(
-                    GetContainingNamespaceOrType(lookupResultSymbol),
+                    GetContainingNamespaceOrNonExtensionType(lookupResultSymbol),
                     ImmutableArray.Create<Symbol>(lookupResultSymbol),
                     lookupResult.Kind,
                     lookupResult.Error,
@@ -2234,7 +2242,7 @@ Symbol resultSymbol(
                         }
 
                         return new ExtendedErrorTypeSymbol(
-                            GetContainingNamespaceOrType(originalSymbols[0]),
+                            GetContainingNamespaceOrNonExtensionType(originalSymbols[0]),
                             originalSymbols,
                             LookupResultKind.Ambiguous,
                             info,
@@ -2252,7 +2260,7 @@ Symbol resultSymbol(
                             wasError = true;
                             var errorInfo = new CSDiagnosticInfo(ErrorCode.ERR_SystemVoid);
                             diagnostics.Add(errorInfo, where.Location);
-                            singleResult = new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(singleResult), singleResult, LookupResultKind.NotReferencable, errorInfo); // UNDONE: Review resultkind.
+                            singleResult = new ExtendedErrorTypeSymbol(GetContainingNamespaceOrNonExtensionType(singleResult), singleResult, LookupResultKind.NotReferencable, errorInfo); // UNDONE: Review resultkind.
                         }
                         // Check for bad symbol.
                         else
@@ -2285,7 +2293,7 @@ Symbol resultSymbol(
                                     {
                                         wasError = true;
                                         diagnostics.Add(errorInfo, where.Location);
-                                        singleResult = new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(errorType), errorType.Name, errorType.Arity, errorInfo, unreported: false);
+                                        singleResult = new ExtendedErrorTypeSymbol(GetContainingNamespaceOrNonExtensionType(errorType), errorType.Name, errorType.Arity, errorInfo, unreported: false);
                                     }
                                 }
                             }
@@ -2341,7 +2349,7 @@ Symbol resultSymbol(
                     // Bad type or namespace (or things expected as types/namespaces) are packaged up as error types, preserving the symbols and the result kind.
                     // We do this if there are multiple symbols too, because just returning one would be losing important information, and they might
                     // be of different kinds.
-                    return new ExtendedErrorTypeSymbol(GetContainingNamespaceOrType(symbols[0]), symbols.ToImmutable(), result.Kind, result.Error, arity);
+                    return new ExtendedErrorTypeSymbol(GetContainingNamespaceOrNonExtensionType(symbols[0]), symbols.ToImmutable(), result.Kind, result.Error, arity);
                 }
                 else
                 {

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -8116,4 +8116,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_ValueParameterSameNameAsExtensionTypeParameter" xml:space="preserve">
     <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 missing.</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2384,6 +2384,7 @@ internal enum ErrorCode
         ERR_TypeParameterSameNameAsExtensionParameter = 9511,
         ERR_InvalidExtensionParameterReference = 9512,
         ERR_ValueParameterSameNameAsExtensionTypeParameter = 9513,
+        ERR_UnderspecifiedExtension = 9514,
 
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2501,6 +2501,7 @@ or ErrorCode.ERR_ValueParameterSameNameAsExtensionParameter
                 or ErrorCode.ERR_TypeParameterSameNameAsExtensionParameter
                 or ErrorCode.ERR_InvalidExtensionParameterReference
                 or ErrorCode.ERR_ValueParameterSameNameAsExtensionTypeParameter
+                or ErrorCode.ERR_UnderspecifiedExtension
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -455,7 +455,7 @@ private void AddNameAndTypeArgumentsOrParameters(INamedTypeSymbol symbol)
 
             return;
 
-            void addExtensionParameter(NamedTypeSymbol? underlyingTypeSymbol) // PROTOTYPE use public API once it's available
+            void addExtensionParameter(NamedTypeSymbol? underlyingTypeSymbol)
             {
                 if (!Format.CompilerInternalOptions.HasFlag(SymbolDisplayCompilerInternalOptions.UseMetadataMemberNames)
                     && underlyingTypeSymbol!.ExtensionParameter is { } extensionParameter)

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

@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -74,6 +75,11 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
 
                 ParameterSymbol? parameter = ParameterHelpers.MakeExtensionReceiverParameter(withTypeParametersBinder: signatureBinder, owner: this, parameterList, diagnostics);
 
+                if (parameter is { })
+                {
+                    checkUnderspecifiedGenericExtension(parameter.Type, ContainingType.TypeParameters, diagnostics, parameter.GetFirstLocation());
+                }
+
                 if (parameter is { Name: var name } && name != "" &&
                     ContainingType.TypeParameters.Any(static (p, name) => p.Name == name, name))
                 {
@@ -82,6 +88,37 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
 
                 return parameter;
             }
+
+            static bool checkUnderspecifiedGenericExtension(TypeSymbol underlyingType, ImmutableArray<TypeParameterSymbol> typeParameters,
+                BindingDiagnosticBag diagnostics, Location location)
+            {
+                var usedTypeParameters = PooledHashSet<TypeParameterSymbol>.GetInstance();
+                underlyingType.VisitType(collectTypeParameters, arg: usedTypeParameters);
+
+                bool anyUnusedTypeParameter = false;
+                foreach (var typeParameter in typeParameters)
+                {
+                    if (!usedTypeParameters.Contains(typeParameter))
+                    {
+                        anyUnusedTypeParameter = true;
+                        diagnostics.Add(ErrorCode.ERR_UnderspecifiedExtension, location, underlyingType, typeParameter);
+                    }
+                }
+
+                usedTypeParameters.Free();
+                return anyUnusedTypeParameter;
+
+                static bool collectTypeParameters(TypeSymbol type, PooledHashSet<TypeParameterSymbol> typeParameters, bool ignored)
+                {
+                    if (type is TypeParameterSymbol typeParameter)
+                    {
+                        typeParameters.Add(typeParameter);
+                    }
+
+                    return false;
+                }
+            }
+
         }
     }
 }