Sema: Minor fixes

Author: slavapestov

lib/AST/Decl.cpp

@@ -2185,7 +2185,7 @@ GenericTypeDecl::GenericTypeDecl(DeclKind K, DeclContext *DC,
 
 
 void GenericTypeDecl::setGenericParams(GenericParamList *params) {
-  // Set the specified generic parameters onto this type alias, setting
+  // Set the specified generic parameters onto this type declaration, setting
   // the parameters' context along the way.
   GenericParams = params;
   if (params)

lib/Sema/TypeCheckDecl.cpp

@@ -4236,7 +4236,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   }
 
   bool semaFuncParamPatterns(AbstractFunctionDecl *fd,
-                             GenericTypeResolver *resolver = nullptr) {
+                             GenericTypeResolver *resolver) {
     bool hadError = false;
     for (auto paramList : fd->getParameterLists()) {
       hadError |= TC.typeCheckParameterList(paramList, fd,
@@ -6449,7 +6449,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
 
     // Type check the constructor parameters.
-    if (CD->isInvalid() || semaFuncParamPatterns(CD)) {
+    GenericTypeToArchetypeResolver resolver;
+    if (CD->isInvalid() || semaFuncParamPatterns(CD, &resolver)) {
       CD->overwriteType(ErrorType::get(TC.Context));
       CD->setInterfaceType(ErrorType::get(TC.Context));
       CD->setInvalid();
@@ -6598,7 +6599,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
           DD->getDeclContext()->getGenericEnvironmentOfContext());
     }
 
-    if (semaFuncParamPatterns(DD)) {
+    GenericTypeToArchetypeResolver resolver;
+    if (semaFuncParamPatterns(DD, &resolver)) {
       DD->overwriteType(ErrorType::get(TC.Context));
       DD->setInterfaceType(ErrorType::get(TC.Context));
       DD->setInvalid();

lib/Sema/TypeCheckGeneric.cpp

@@ -466,18 +466,14 @@ static Type getResultType(TypeChecker &TC, FuncDecl *fn, Type resultType) {
     // in the TypeRepr.  Because of this, Sema isn't able to rebuild it in
     // terms of interface types.  When interface types prevail, this should be
     // removed.  Until then, we hack the mapping here.
-    return ArchetypeBuilder::mapTypeOutOfContext(fn, resultType);
+    return ArchetypeBuilder::mapTypeOutOfContext(fn->getDeclContext(), resultType);
   }
 
   return resultType;
 }
 
 GenericEnvironment *
 TypeChecker::markInvalidGenericSignature(DeclContext *DC) {
-  // If there aren't any generic parameters at this level, we're done.
-  if (!DC->isInnermostContextGeneric())
-    return nullptr;
-
   GenericParamList *genericParams = DC->getGenericParamsOfContext();
   GenericSignature *genericSig = DC->getGenericSignatureOfContext();
 
@@ -488,20 +484,24 @@ TypeChecker::markInvalidGenericSignature(DeclContext *DC) {
   auto parentSig = parentDC->getGenericSignatureOfContext();
   auto parentEnv = parentDC->getGenericEnvironmentOfContext();
 
+  assert(parentSig != nullptr || DC->isInnermostContextGeneric());
+
   if (parentSig != nullptr)
     builder.addGenericSignature(parentSig, parentEnv);
 
-  // Visit each of the generic parameters.
-  for (auto param : *genericParams)
-    builder.addGenericParameter(param);
+  if (DC->isInnermostContextGeneric()) {
+    // Visit each of the generic parameters.
+    for (auto param : *genericParams)
+      builder.addGenericParameter(param);
+
+    for (auto GP : *genericParams)
+      GP->setArchetype(builder.getArchetype(GP));
+  }
 
   // Wire up the archetypes.
   auto genericEnv = builder.getGenericEnvironment(
       genericSig->getGenericParams());
 
-  for (auto GP : *genericParams)
-    GP->setArchetype(builder.getArchetype(GP));
-
   return genericEnv;
 }
 
@@ -626,7 +626,7 @@ void TypeChecker::configureInterfaceType(AbstractFunctionDecl *func) {
         initArgTy = func->computeInterfaceSelfType(/*isInitializingCtor=*/true);
       }
     } else {
-      argTy = paramLists[e - i - 1]->getInterfaceType(func);
+      argTy = paramLists[e - i - 1]->getInterfaceType(func->getDeclContext());
 
       if (initFuncTy)
         initArgTy = argTy;

lib/Sema/TypeCheckType.cpp

@@ -629,21 +629,22 @@ static void diagnoseUnboundGenericType(TypeChecker &tc, Type ty,SourceLoc loc) {
       // Currently it only works if all the generic arguments have a super type,
       // or it requires a class, in which case it infers 'AnyObject'.
       auto inferGenericArgs = [](GenericTypeDecl *genericD)->std::string {
-        GenericParamList *genParamList = genericD->getGenericParams();
-        if (!genParamList)
+        auto *mod = genericD->getParentModule();
+        auto *genericSig = genericD->getGenericSignature();
+        if (!genericSig)
           return std::string();
-        auto params= genParamList->getParams();
+
+        auto params = genericSig->getInnermostGenericParams();
         if (params.empty())
           return std::string();
         std::string argsToAdd = "<";
         for (unsigned i = 0, e = params.size(); i != e; ++i) {
           auto param = params[i];
-          auto archTy = param->getArchetype();
-          if (!archTy)
-            return std::string();
-          if (auto superTy = archTy->getSuperclass()) {
+          if (auto superTy = genericSig->getSuperclassBound(param, *mod)) {
+            if (superTy->hasTypeParameter())
+              return std::string(); // give up
             argsToAdd += superTy.getString();
-          } else if (archTy->requiresClass()) {
+          } else if (genericSig->requiresClass(param, *mod)) {
             argsToAdd += "AnyObject";
           } else {
             return std::string(); // give up.