Rebrand TR_NominalInheritanceClause as TR_GenericSignature, and support functions.

It’s real intent is to check only the generic signature of the DeclContext provided to name lookup, then enclosing contexts. Use it for functions and initializers as well, so we have uniform lookup behavior for entities that can have generic parameters.

A follow-up commit contains some minor, semi-related tweaks along with a pile of updates to the compiler crash testsuite.

Swift SVN r26654

Author: DougGregor

lib/Sema/TypeCheckDecl.cpp

@@ -265,13 +265,10 @@ void TypeChecker::resolveRawType(EnumDecl *enumDecl) {
 }
 
 void TypeChecker::resolveInheritanceClause(DeclContext *dc) {
-  TypeResolutionOptions options;
-
   // FIXME: Add a cached bit so this isn't O(n) in repeated calls.
   MutableArrayRef<TypeLoc> inheritanceClause;
   if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
     inheritanceClause = nominal->getInherited();
-    options |= TR_NominalInheritanceClause;
   } else {
     auto ext = cast<ExtensionDecl>(dc);
     inheritanceClause = ext->getInherited();
@@ -281,7 +278,7 @@ void TypeChecker::resolveInheritanceClause(DeclContext *dc) {
   PartialGenericTypeToArchetypeResolver resolver(*this);
 
   for (auto &inherited : inheritanceClause) {
-    if (validateType(inherited, dc, options, &resolver)) {
+    if (validateType(inherited, dc, TR_GenericSignature, &resolver)) {
       inherited.setInvalidType(Context);
       continue;
     }
@@ -299,20 +296,23 @@ void TypeChecker::checkInheritanceClause(Decl *decl,
   DeclContext *DC;
   if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
     DC = nominal;
-    options |= TR_NominalInheritanceClause;
+    options |= TR_GenericSignature;
   } else if (auto ext = dyn_cast<ExtensionDecl>(decl)) {
     DC = ext;
-    options |= TR_NominalInheritanceClause;
+    options |= TR_GenericSignature;
   } else if (isa<GenericTypeParamDecl>(decl)) {
     // For generic parameters, we want name lookup to look at just the
     // signature of the enclosing entity.
     DC = decl->getDeclContext();
     if (auto nominal = dyn_cast<NominalTypeDecl>(DC)) {
       DC = nominal;
-      options |= TR_NominalInheritanceClause;
+      options |= TR_GenericSignature;
     } else if (auto ext = dyn_cast<ExtensionDecl>(DC)) {
       DC = ext;
-      options |= TR_NominalInheritanceClause;
+      options |= TR_GenericSignature;
+    } else if (auto func = dyn_cast<AbstractFunctionDecl>(DC)) {
+      DC = func;
+      options |= TR_GenericSignature;
     } else if (!DC->isModuleScopeContext()) {
       // Skip the generic parameter's context entirely.
       DC = DC->getParent();

lib/Sema/TypeCheckType.cpp

@@ -297,7 +297,7 @@ Type TypeChecker::applyGenericArguments(Type type,
                                         SourceLoc loc,
                                         DeclContext *dc,
                                         MutableArrayRef<TypeLoc> genericArgs,
-                                        bool isNominalInheritanceClause,
+                                        bool isGenericSignature,
                                         GenericTypeResolver *resolver) {
   // Make sure we always have a resolver to use.
   PartialGenericTypeToArchetypeResolver defaultResolver(*this);
@@ -330,8 +330,8 @@ Type TypeChecker::applyGenericArguments(Type type,
   }
 
   TypeResolutionOptions options;
-  if (isNominalInheritanceClause)
-    options |= TR_NominalInheritanceClause;
+  if (isGenericSignature)
+    options |= TR_GenericSignature;
 
   // Validate the generic arguments and capture just the types.
   SmallVector<Type, 4> genericArgTypes;
@@ -370,13 +370,13 @@ Type TypeChecker::applyGenericArguments(Type type,
 static Type applyGenericTypeReprArgs(TypeChecker &TC, Type type, SourceLoc loc,
                                      DeclContext *dc,
                                      ArrayRef<TypeRepr *> genericArgs,
-                                     bool isNominalInheritanceClause,
+                                     bool isGenericSignature,
                                      GenericTypeResolver *resolver) {
   SmallVector<TypeLoc, 8> args;
   for (auto tyR : genericArgs)
     args.push_back(tyR);
   Type ty = TC.applyGenericArguments(type, loc, dc, args,
-                                     isNominalInheritanceClause, resolver);
+                                     isGenericSignature, resolver);
   if (!ty)
     return ErrorType::get(TC.Context);
   return ty;
@@ -396,7 +396,7 @@ static Type resolveTypeDecl(TypeChecker &TC, TypeDecl *typeDecl, SourceLoc loc,
                             DeclContext *dc,
                             ArrayRef<TypeRepr *> genericArgs,
                             bool allowUnboundGenerics,
-                            bool isNominalInheritanceClause,
+                            bool isGenericSignature,
                             GenericTypeResolver *resolver) {
   TC.validateDecl(typeDecl);
 
@@ -432,7 +432,7 @@ static Type resolveTypeDecl(TypeChecker &TC, TypeDecl *typeDecl, SourceLoc loc,
   if (!genericArgs.empty()) {
     // Apply the generic arguments to the type.
     type = applyGenericTypeReprArgs(TC, type, loc, dc, genericArgs,
-                                    isNominalInheritanceClause, resolver);
+                                    isGenericSignature, resolver);
   }
 
   assert(type);
@@ -459,15 +459,15 @@ static NominalTypeDecl *getEnclosingNominalContext(DeclContext *dc) {
 /// \param dc The context in which name lookup occurred.
 /// \param components The components that refer to the type, where the last
 /// component refers to the type that could not be found.
-/// \param isNominalInheritanceClause True if this type is in a nominal's
-/// inheritance clause.
+/// \param isGenericSignature True if we're only looking into the generic
+/// signature of the given context.
 ///
 /// \returns true if we could not fix the type reference, false if
 /// typo correction (or some other mechanism) was able to fix the
 /// reference.
 static bool diagnoseUnknownType(TypeChecker &tc, DeclContext *dc,
                                 ArrayRef<ComponentIdentTypeRepr *> components,
-                                bool isNominalInheritanceClause,
+                                bool isGenericSignature,
                                 GenericTypeResolver *resolver) {
   auto comp = components.back();
 
@@ -483,7 +483,7 @@ static bool diagnoseUnknownType(TypeChecker &tc, DeclContext *dc,
       assert(!isa<ProtocolDecl>(nominal) && "Cannot be a protocol");
       auto type = resolveTypeDecl(tc, nominal, comp->getIdLoc(), dc, { },
                                   /*allowUnboundGenerics=*/false,
-                                  isNominalInheritanceClause, resolver);
+                                  isGenericSignature, resolver);
       if (type->is<ErrorType>())
         return true;
 
@@ -561,7 +561,7 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
   // Resolve the first component, which is the only one that requires
   // unqualified name lookup.
   DeclContext *lookupDC = DC;
-  if (options.contains(TR_NominalInheritanceClause))
+  if (options.contains(TR_GenericSignature))
     lookupDC = DC->getParent();
   UnqualifiedLookup Globals(comp->getIdentifier(), lookupDC, &TC,
                             options.contains(TR_KnownNonCascadingDependency),
@@ -601,7 +601,7 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
     Type type = resolveTypeDecl(TC, typeDecl, comp->getIdLoc(),
                                 DC, genericArgs,
                                 options.contains(TR_AllowUnboundGenerics),
-                                options.contains(TR_NominalInheritanceClause),
+                                options.contains(TR_GenericSignature),
                                 resolver);
     if (type->is<ErrorType>()) {
       comp->setValue(type);
@@ -650,7 +650,7 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
     // source, bail out.
     if (!diagnoseErrors ||
         diagnoseUnknownType(TC, DC, comp,
-                            options.contains(TR_NominalInheritanceClause),
+                            options.contains(TR_GenericSignature),
                             resolver)) {
       Type ty = ErrorType::get(TC.Context);
       comp->setValue(ty);
@@ -671,15 +671,17 @@ resolveIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
     if (parentComps.empty()) {
       TypeResolutionOptions lookupOptions = options;
 
-      // For inheritance clause lookups, don't actually look into the type.
-      // Just look at the generic parameters, and then move up to the enclosing
-      // context.
-      if (options.contains(TR_NominalInheritanceClause)) {
+      // For lookups within the generic signature, look at the generic
+      // parameters (only), then move up to the enclosing context.
+      if (options.contains(TR_GenericSignature)) {
         GenericParamList *genericParams;
-        if (auto *nominal = dyn_cast<NominalTypeDecl>(DC))
+        if (auto *nominal = dyn_cast<NominalTypeDecl>(DC)) {
           genericParams = nominal->getGenericParams();
-        else
-          genericParams = cast<ExtensionDecl>(DC)->getGenericParams();
+        } else if (auto *ext = dyn_cast<ExtensionDecl>(DC)) {
+          genericParams = ext->getGenericParams();
+        } else {
+          genericParams = cast<AbstractFunctionDecl>(DC)->getGenericParams();
+        }
 
         if (!isa<GenericIdentTypeRepr>(comp)) {
           if (genericParams) {
@@ -773,13 +775,14 @@ resolveIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
         }
 
         // If we didn't find anything, complain.
-        bool isNominal = options.contains(TR_NominalInheritanceClause);
+        bool isGenericSignature = options.contains(TR_GenericSignature);
         bool recovered = false;
         if (!memberTypes) {
           // If we're not allowed to complain or we couldn't fix the
           // source, bail out.
           if (!diagnoseErrors || 
-              diagnoseUnknownType(TC, DC, components, isNominal, resolver)) {
+              diagnoseUnknownType(TC, DC, components, isGenericSignature,
+                                  resolver)) {
             Type ty = ErrorType::get(TC.Context);
             comp->setValue(ty);
             return ty;
@@ -804,7 +807,7 @@ resolveIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
           memberType = applyGenericTypeReprArgs(TC, memberType,
                                                 genComp->getIdLoc(),
                                                 DC, genComp->getGenericArgs(),
-                                                isNominal, resolver);
+                                                isGenericSignature, resolver);
 
         comp->setValue(memberType);
         return memberType;
@@ -836,11 +839,12 @@ resolveIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
       }
 
       // If we didn't find a type, complain.
-      bool isNominal = options.contains(TR_NominalInheritanceClause);
+      bool isGenericSignature = options.contains(TR_GenericSignature);
       bool recovered = false;
       if (!foundModuleTypes) {
         if (!diagnoseErrors || 
-            diagnoseUnknownType(TC, DC, components, isNominal, resolver)) {
+            diagnoseUnknownType(TC, DC, components, isGenericSignature,
+                                resolver)) {
           Type ty = ErrorType::get(TC.Context);
           comp->setValue(ty);
           return ty;
@@ -856,7 +860,7 @@ resolveIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
       if (auto genComp = dyn_cast<GenericIdentTypeRepr>(comp)) {
         foundType = applyGenericTypeReprArgs(TC, foundType, genComp->getIdLoc(),
                                              DC, genComp->getGenericArgs(),
-                                             isNominal, resolver);
+                                             isGenericSignature, resolver);
       }
 
       comp->setValue(foundType);
@@ -888,7 +892,7 @@ resolveIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
   Type type = resolveTypeDecl(TC, typeDecl, comp->getIdLoc(), DC,
                               genericArgs, 
                               options.contains(TR_AllowUnboundGenerics),
-                              options.contains(TR_NominalInheritanceClause),
+                              options.contains(TR_GenericSignature),
                               resolver);
   comp->setValue(type);
   return type;
@@ -1739,7 +1743,7 @@ Type TypeResolver::resolveDictionaryType(DictionaryTypeRepr *repr,
     TypeLoc args[2] = { TypeLoc(repr->getKey()), TypeLoc(repr->getValue()) };
 
     if (!TC.applyGenericArguments(unboundTy, repr->getStartLoc(), DC, args,
-                                  options.contains(TR_NominalInheritanceClause),
+                                  options.contains(TR_GenericSignature),
                                   Resolver)) {
       return ErrorType::get(TC.Context);
     }

lib/Sema/TypeChecker.h

@@ -209,9 +209,9 @@ enum TypeResolutionFlags {
   /// Whether we are the variable type in a for/in statement.
   TR_EnumerationVariable = 0x200,
 
-  /// Whether this type is being used in the inheritance clause of a nominal
-  /// type.
-  TR_NominalInheritanceClause = 0x800,
+  /// Whether we are looking only in the generic signature of the context
+  /// we're searching, rather than the entire context.
+  TR_GenericSignature = 0x800,
 
   /// Whether this type is the referent of a global type alias.
   TR_GlobalTypeAlias = 0x1000,
@@ -507,8 +507,8 @@ class TypeChecker final : public LazyResolver {
   /// \param loc The source location for diagnostic reporting.
   /// \param dc The context where the arguments are applied.
   /// \param genericArgs The list of generic arguments to apply to the type.
-  /// \param isNominalInheritanceClause True if these generic arguments appear
-  /// in the inheritance clause of a nominal type.
+  /// \param isGenericSignature True if we are looking only in the generic
+  /// signature of the context.
   /// \param resolver The generic type resolver.
   ///
   /// \returns A BoundGenericType bound to the given arguments, or null on
@@ -517,7 +517,7 @@ class TypeChecker final : public LazyResolver {
                              SourceLoc loc,
                              DeclContext *dc,
                              MutableArrayRef<TypeLoc> genericArgs,
-                             bool isNominalInheritanceClause,
+                             bool isGenericSignature,
                              GenericTypeResolver *resolver);
 
   /// \brief Substitute the given base type into the type of the given member,

test/Sema/circular_decl_checking.swift

@@ -15,10 +15,10 @@ class HasFunc {
 }
 
 class HasGenericFunc {
-  func HasGenericFunc<HasGenericFunc : HasGenericFunc>(x: HasGenericFunc) -> HasGenericFunc { // expected-error {{use of undeclared type 'HasGenericFunc'}}
+  func HasGenericFunc<HasGenericFunc : HasGenericFunc>(x: HasGenericFunc) -> HasGenericFunc { // expected-error {{inheritance from non-protocol, non-class type 'HasGenericFunc'}}
     return x
   }
-  func SomethingElse<SomethingElse : SomethingElse>(_: SomethingElse) -> SomethingElse? { // expected-error {{use of undeclared type 'SomethingElse'}}
+  func SomethingElse<SomethingElse : SomethingElse>(_: SomethingElse) -> SomethingElse? { // expected-error {{inheritance from non-protocol, non-class type 'SomethingElse'}}
     return nil
   }
 }
@@ -38,6 +38,6 @@ protocol ReferenceSomeProtocol {
 }
 
 func TopLevelFunc(x: TopLevelFunc) -> TopLevelFunc { return x } // expected-error {{use of undeclared type 'TopLevelFunc'}}'
-func TopLevelGenericFunc<TopLevelGenericFunc : TopLevelGenericFunc>(x: TopLevelGenericFunc) -> TopLevelGenericFunc { return x } // expected-error {{use of undeclared type 'TopLevelGenericFunc'}}'
+func TopLevelGenericFunc<TopLevelGenericFunc : TopLevelGenericFunc>(x: TopLevelGenericFunc) -> TopLevelGenericFunc { return x } // expected-error {{inheritance from non-protocol, non-class type 'TopLevelGenericFunc'}}
 func TopLevelGenericFunc2<T : TopLevelGenericFunc2>(x: T) -> T { return x} // expected-error {{use of undeclared type 'TopLevelGenericFunc2'}}
 var TopLevelVar: TopLevelVar? { return nil } // expected-error 2 {{use of undeclared type 'TopLevelVar'}}