Merge pull request #18720 from DougGregor/kill-type-resolver-context-generic-signature

swift-ci · web-flow · commit be0e1643d61a · 2018-08-15T10:55:08.000-07:00
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -3779,10 +3779,6 @@ struct SelfReferenceKind {
 class ProtocolDecl final : public NominalTypeDecl {
   SourceLoc ProtocolLoc;
 
-  /// The syntactic representation of the where clause in a protocol like
-  /// `protocol ... where ... { ... }`.
-  TrailingWhereClause *TrailingWhere;
-
   llvm::DenseMap<ValueDecl *, Witness> DefaultWitnesses;
 
   /// The generic signature representing exactly the new requirements introduced
@@ -3995,11 +3991,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// created yet.
   void createGenericParamsIfMissing();
 
-  /// Retrieve the trailing where clause on this protocol, if it exists.
-  TrailingWhereClause *getTrailingWhereClause() const {
-    return TrailingWhere;
-  }
-
   /// Retrieve the requirements that describe this protocol.
   ///
   /// These are the requirements including any inherited protocols
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -3569,7 +3569,7 @@ ProtocolDecl::ProtocolDecl(DeclContext *DC, SourceLoc ProtocolLoc,
                            TrailingWhereClause *TrailingWhere)
     : NominalTypeDecl(DeclKind::Protocol, DC, Name, NameLoc, Inherited,
                       nullptr),
-      ProtocolLoc(ProtocolLoc), TrailingWhere(TrailingWhere) {
+      ProtocolLoc(ProtocolLoc) {
   Bits.ProtocolDecl.RequiresClassValid = false;
   Bits.ProtocolDecl.RequiresClass = false;
   Bits.ProtocolDecl.ExistentialConformsToSelfValid = false;
@@ -3579,6 +3579,7 @@ ProtocolDecl::ProtocolDecl(DeclContext *DC, SourceLoc ProtocolLoc,
   Bits.ProtocolDecl.NumRequirementsInSignature = 0;
   Bits.ProtocolDecl.HasMissingRequirements = false;
   Bits.ProtocolDecl.KnownProtocol = 0;
+  setTrailingWhereClause(TrailingWhere);
 }
 
 llvm::TinyPtrVector<ProtocolDecl *>
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
@@ -7491,6 +7491,17 @@ GenericSignature *GenericSignatureBuilder::computeGenericSignature(
   return sig;
 }
 
+/// Add all of the generic parameters from the given parameter list (and it's
+/// outer generic parameter lists) to the given generic signature builder.
+static void addAllGenericParams(GenericSignatureBuilder &builder,
+                                GenericParamList *genericParams) {
+  if (!genericParams) return;
+
+  addAllGenericParams(builder, genericParams->getOuterParameters());
+  for (auto gp : *genericParams)
+    builder.addGenericParameter(gp);
+}
+
 GenericSignature *GenericSignatureBuilder::computeRequirementSignature(
                                                      ProtocolDecl *proto) {
   GenericSignatureBuilder builder(proto->getASTContext());
@@ -7501,12 +7512,12 @@ GenericSignature *GenericSignatureBuilder::computeRequirementSignature(
       lazyResolver->resolveDeclSignature(proto);
   }
 
-  // Add the 'self' parameter.
-  auto selfType =
-    proto->getSelfInterfaceType()->castTo<GenericTypeParamType>();
-  builder.addGenericParameter(selfType);
+  // Add all of the generic parameters.
+  addAllGenericParams(builder, proto->getGenericParams());
 
   // Add the conformance of 'self' to the protocol.
+  auto selfType =
+    proto->getSelfInterfaceType()->castTo<GenericTypeParamType>();
   auto requirement =
     Requirement(RequirementKind::Conformance, selfType,
                 proto->getDeclaredInterfaceType());
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -579,6 +579,41 @@ SelfBoundsFromWhereClauseRequest::evaluate(Evaluator &evaluator,
   return result;
 }
 
+namespace {
+
+/// Determine whether unqualified lookup should look at the members of the
+/// given nominal type or extension, vs. only looking at type parameters.
+template<typename D>
+bool shouldLookupMembers(D *decl, SourceLoc loc) {
+  // Only look at members of this type (or its inherited types) when
+  // inside the body or a protocol's top-level 'where' clause. (Why the
+  // 'where' clause? Because that's where you put constraints on
+  // inherited associated types.)
+
+  // When we have no source-location information, we have to perform member
+  // lookup.
+  if (loc.isInvalid() || decl->getBraces().isInvalid())
+    return true;
+
+  // Within the braces, always look for members.
+  auto &ctx = decl->getASTContext();
+  if (ctx.SourceMgr.rangeContainsTokenLoc(decl->getBraces(), loc))
+    return true;
+
+  // Within 'where' clause, we can also look for members.
+  if (auto *whereClause = decl->getTrailingWhereClause()) {
+    SourceRange whereClauseRange = whereClause->getSourceRange();
+    if (whereClauseRange.isValid() &&
+        ctx.SourceMgr.rangeContainsTokenLoc(whereClauseRange, loc)) {
+      return true;
+    }
+  }
+
+  // Don't look at the members.
+  return false;
+}
+} // end anonymous namespace
+
 UnqualifiedLookup::UnqualifiedLookup(DeclName Name, DeclContext *DC,
                                      LazyResolver *TypeResolver, SourceLoc Loc,
                                      Options options)
@@ -922,14 +957,16 @@ UnqualifiedLookup::UnqualifiedLookup(DeclName Name, DeclContext *DC,
             continue;
           }
 
-          populateLookupDeclsFromContext(ED);
+          if (shouldLookupMembers(ED, Loc))
+            populateLookupDeclsFromContext(ED);
 
           BaseDC = ED;
           MetaBaseDC = ED;
           if (!isCascadingUse.hasValue())
             isCascadingUse = ED->isCascadingContextForLookup(false);
         } else if (auto *ND = dyn_cast<NominalTypeDecl>(DC)) {
-          populateLookupDeclsFromContext(ND);
+          if (shouldLookupMembers(ND, Loc))
+            populateLookupDeclsFromContext(ND);
           BaseDC = DC;
           MetaBaseDC = DC;
           if (!isCascadingUse.hasValue())
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -3192,7 +3192,17 @@ Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass,
 
     t = t->getSuperclass(useArchetypes);
   }
-  llvm_unreachable("no inheritance relationship between given classes");
+
+#ifndef NDEBUG
+  auto *currentClass = getConcreteTypeForSuperclassTraversing(this)
+      ->getClassOrBoundGenericClass();
+  while (currentClass && currentClass != baseClass)
+    currentClass = currentClass->getSuperclassDecl();
+  assert(currentClass == baseClass &&
+         "no inheritance relationship between given classes");
+#endif
+
+  return ErrorType::get(this);
 }
 
 TypeSubstitutionMap
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -244,29 +244,10 @@ void TypeChecker::checkInheritanceClause(Decl *decl,
   DeclContext *DC;
   if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
     DC = nominal;
-    options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
     options |= TypeResolutionFlags::AllowUnavailableProtocol;
   } else if (auto ext = dyn_cast<ExtensionDecl>(decl)) {
     DC = ext;
-    options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
     options |= TypeResolutionFlags::AllowUnavailableProtocol;
-  } 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 = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-    } else if (auto ext = dyn_cast<ExtensionDecl>(DC)) {
-      DC = ext;
-      options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-    } else if (auto func = dyn_cast<AbstractFunctionDecl>(DC)) {
-      DC = func;
-      options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-    } else if (!DC->isModuleScopeContext()) {
-      // Skip the generic parameter's context entirely.
-      DC = DC->getParent();
-    }
   } else {
     DC = decl->getDeclContext();
   }
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -242,18 +242,9 @@ void TypeChecker::checkGenericParamList(GenericSignatureBuilder *builder,
   assert(genericParams->size() > 0 &&
          "Parsed an empty generic parameter list?");
 
-  // Determine where and how to perform name lookup for the generic
-  // parameter lists and where clause.
+  // Determine where and how to perform name lookup.
   TypeResolutionOptions options = None;
   DeclContext *lookupDC = genericParams->begin()[0]->getDeclContext();
-  if (!lookupDC->isModuleScopeContext()) {
-    assert((isa<GenericTypeDecl>(lookupDC) ||
-            isa<ExtensionDecl>(lookupDC) ||
-            isa<AbstractFunctionDecl>(lookupDC) ||
-            isa<SubscriptDecl>(lookupDC)) &&
-           "not a proper generic parameter context?");
-    options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-  }    
 
   // First, add the generic parameters to the generic signature builder.
   // Do this before checking the inheritance clause, since it may
diff --git a/lib/Sema/TypeCheckRequestFunctions.cpp b/lib/Sema/TypeCheckRequestFunctions.cpp
@@ -30,33 +30,13 @@ Type InheritedTypeRequest::evaluate(
   if (auto typeDecl = decl.dyn_cast<TypeDecl *>()) {
     if (auto nominal = dyn_cast<NominalTypeDecl>(typeDecl)) {
       dc = nominal;
-      options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
       options |= TypeResolutionFlags::AllowUnavailableProtocol;
     } else {
       dc = typeDecl->getDeclContext();
-
-      if (isa<GenericTypeParamDecl>(typeDecl)) {
-        // For generic parameters, we want name lookup to look at just the
-        // signature of the enclosing entity.
-        if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
-          dc = nominal;
-          options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-        } else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
-          dc = ext;
-          options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-        } else if (auto func = dyn_cast<AbstractFunctionDecl>(dc)) {
-          dc = func;
-          options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
-        } else if (!dc->isModuleScopeContext()) {
-          // Skip the generic parameter's context entirely.
-          dc = dc->getParent();
-        }
-      }
     }
   } else {
     auto ext = decl.get<ExtensionDecl *>();
     dc = ext;
-    options = TypeResolutionOptions(TypeResolverContext::GenericSignature);
     options |= TypeResolutionFlags::AllowUnavailableProtocol;
   }
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -297,8 +297,12 @@ Type TypeChecker::resolveTypeInContext(
       //
       // Get the superclass of the 'Self' type parameter.
       auto *sig = foundDC->getGenericSignatureOfContext();
+      if (!sig)
+        return ErrorType::get(Context);
       auto superclassType = sig->getSuperclassBound(selfType);
-      assert(superclassType);
+      if (!superclassType)
+        return ErrorType::get(Context);
+
       selfType = superclassType;
     }
   }
@@ -763,15 +767,12 @@ static Type diagnoseUnknownType(TypeChecker &tc, DeclContext *dc,
 
     // Try ignoring access control.
     DeclContext *lookupDC = dc;
-    if (options.getBaseContext() == TypeResolverContext::GenericSignature)
-      lookupDC = dc->getParentForLookup();
-
     NameLookupOptions relookupOptions = lookupOptions;
     relookupOptions |= NameLookupFlags::KnownPrivate;
     relookupOptions |= NameLookupFlags::IgnoreAccessControl;
     auto inaccessibleResults =
-        tc.lookupUnqualifiedType(lookupDC, comp->getIdentifier(), comp->getIdLoc(),
-                                 relookupOptions);
+        tc.lookupUnqualifiedType(lookupDC, comp->getIdentifier(),
+                                 comp->getIdLoc(), relookupOptions);
     if (!inaccessibleResults.empty()) {
       // FIXME: What if the unviable candidates have different levels of access?
       auto first = cast<TypeDecl>(inaccessibleResults.front().getValueDecl());
@@ -890,84 +891,6 @@ static Type diagnoseUnknownType(TypeChecker &tc, DeclContext *dc,
   return ErrorType::get(tc.Context);
 }
 
-static Type
-resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
-                                  ComponentIdentTypeRepr *comp,
-                                  TypeResolutionOptions options,
-                                  GenericTypeResolver *resolver);
-
-static Type
-resolveGenericSignatureComponent(TypeChecker &TC, DeclContext *DC,
-                                 ComponentIdentTypeRepr *comp,
-                                 TypeResolutionOptions options,
-                                 GenericTypeResolver *resolver) {
-  if (!DC->isInnermostContextGeneric())
-    return Type();
-
-  auto *genericParams = DC->getGenericParamsOfContext();
-
-  if (!isa<ExtensionDecl>(DC)) {
-    auto matchingParam =
-      std::find_if(genericParams->begin(), genericParams->end(),
-                   [comp](const GenericTypeParamDecl *param) {
-                     return param->getFullName().matchesRef(comp->getIdentifier());
-                   });
-
-    if (matchingParam == genericParams->end())
-      return Type();
-
-    comp->setValue(*matchingParam, nullptr);
-    return resolveTopLevelIdentTypeComponent(TC, DC, comp, options, resolver);
-  }
-
-  // If we are inside an extension of a nested type, we have to visit
-  // all outer parameter lists. Otherwise, we will visit them when
-  // name lookup goes ahead and checks the outer DeclContext.
-  for (auto *outerParams = genericParams;
-       outerParams != nullptr;
-       outerParams = outerParams->getOuterParameters()) {
-    auto matchingParam =
-      std::find_if(outerParams->begin(), outerParams->end(),
-                   [comp](const GenericTypeParamDecl *param) {
-                     return param->getFullName().matchesRef(comp->getIdentifier());
-                   });
-
-    if (matchingParam != outerParams->end()) {
-      comp->setValue(*matchingParam, nullptr);
-      return resolveTopLevelIdentTypeComponent(TC, DC, comp, options, resolver);
-    }
-  }
-
-  // If the lookup occurs from within a trailing 'where' clause of
-  // a constrained extension, also look for associated types and typealiases
-  // in the protocol.
-  if (genericParams->hasTrailingWhereClause() &&
-      comp->getIdLoc().isValid() &&
-      TC.Context.SourceMgr.rangeContainsTokenLoc(
-        genericParams->getTrailingWhereClauseSourceRange(),
-          comp->getIdLoc())) {
-    auto nominal = DC->getAsNominalTypeOrNominalTypeExtensionContext();
-    SmallVector<ValueDecl *, 4> decls;
-    if (DC->lookupQualified(nominal,
-                            comp->getIdentifier(),
-                            NL_OnlyTypes|NL_QualifiedDefault|NL_ProtocolMembers,
-                            decls)) {
-      for (const auto decl : decls) {
-        // FIXME: Better ambiguity handling.
-        auto typeDecl = cast<TypeDecl>(decl);
-
-        if (!isa<ProtocolDecl>(typeDecl->getDeclContext())) continue;
-
-        comp->setValue(typeDecl, DC);
-        return resolveTopLevelIdentTypeComponent(TC, DC, comp, options,
-                                                 resolver);
-      }
-    }
-  }
-
-  return Type();
-}
-
 /// Resolve the given identifier type representation as an unqualified type,
 /// returning the type it references.
 ///
@@ -1010,20 +933,6 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
     return DynamicSelfType::get(selfType, TC.Context);
   }
 
-  // For lookups within the generic signature, look at the generic
-  // parameters (only), then move up to the enclosing context.
-  if (options.getBaseContext() == TypeResolverContext::GenericSignature) {
-    Type type = resolveGenericSignatureComponent(
-      TC, DC, comp, options, resolver);
-    if (type)
-      return type;
-
-    if (!DC->isCascadingContextForLookup(/*excludeFunctions*/false))
-      options |= TypeResolutionFlags::KnownNonCascadingDependency;
-
-    lookupDC = DC->getParentForLookup();
-  }
-
   auto id = comp->getIdentifier();
 
   NameLookupOptions lookupOptions = defaultUnqualifiedLookupOptions;
@@ -2692,7 +2601,6 @@ Type TypeResolver::resolveImplicitlyUnwrappedOptionalType(
   case TypeResolverContext::EnumPatternPayload:
   case TypeResolverContext::TypeAliasDecl:
   case TypeResolverContext::GenericRequirement:
-  case TypeResolverContext::GenericSignature:
   case TypeResolverContext::ImmediateOptionalTypeArgument:
   case TypeResolverContext::InExpression:
   case TypeResolverContext::EditorPlaceholderExpr:
@@ -2945,7 +2853,10 @@ Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
           nominalDecl, baseTy,
           nominalDecl->getASTContext());
     }
-    
+
+    if (baseTy && baseTy->is<ErrorType>())
+      return baseTy;
+
     return NominalType::get(
         nominalDecl, baseTy,
         nominalDecl->getASTContext());
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
diff --git a/test/decl/typealias/protocol.swift b/test/decl/typealias/protocol.swift
diff --git a/validation-test/compiler_crashers_2_fixed/0153-rdar39130543.swift b/validation-test/compiler_crashers_2_fixed/0153-rdar39130543.swift
