Merge pull request #17870 from slavapestov/fix-compiler-crashers

Fix compiler crashers

Author: slavapestov

include/swift/AST/Types.h

@@ -767,9 +767,12 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
   /// \brief Retrieve the superclass of this type.
   ///
+  /// \param useArchetypes Whether to use context archetypes for outer generic
+  /// parameters if the class is nested inside a generic function.
+  ///
   /// \returns The superclass of this type, or a null type if it has no
   ///          superclass.
-  Type getSuperclass();
+  Type getSuperclass(bool useArchetypes = true);
 
   /// \brief True if this type is the exact superclass of another type.
   ///
@@ -797,7 +800,11 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   ///
   /// Calling `C<String, NSObject>`->getSuperclassForDecl(`A`) will return
   /// `A<Int, NSObject>`.
-  Type getSuperclassForDecl(const ClassDecl *classDecl);
+  ///
+  /// \param useArchetypes Whether to use context archetypes for outer generic
+  /// parameters if the class is nested inside a generic function.
+  Type getSuperclassForDecl(const ClassDecl *classDecl,
+                            bool useArchetypes = true);
 
   /// \brief Whether this type or its superclasses has some form of generic
   /// context.

lib/AST/ConformanceLookupTable.cpp

@@ -319,6 +319,10 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
           return;
         llvm::SaveAndRestore<bool> visiting(VisitingSuperclass, true);
 
+        // Don't update our own lookup table if we inherit from ourselves.
+        if (classDecl == superclassDecl)
+          break;
+
         // Resolve the conformances of the superclass.
         superclassDecl->prepareConformanceTable();
         superclassDecl->ConformanceTable->updateLookupTable(

lib/AST/LookupVisibleDecls.cpp

@@ -847,10 +847,6 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
 
     // Does it make sense to substitute types?
 
-    // Don't pass UnboundGenericType here. If you see this assertion
-    // being hit, fix the caller, don't remove it.
-    assert(IsTypeLookup || !BaseTy->hasUnboundGenericType());
-
     // If the base type is AnyObject, we might be doing a dynamic
     // lookup, so the base type won't match the type of the member's
     // context type.

lib/AST/Type.cpp

@@ -1461,7 +1461,7 @@ bool TypeBase::satisfiesClassConstraint() {
   return mayHaveSuperclass() || isObjCExistentialType();
 }
 
-Type TypeBase::getSuperclass() {
+Type TypeBase::getSuperclass(bool useArchetypes) {
   auto *nominalDecl = getAnyNominal();
   auto *classDecl = dyn_cast_or_null<ClassDecl>(nominalDecl);
 
@@ -1496,7 +1496,9 @@ Type TypeBase::getSuperclass() {
   ModuleDecl *module = classDecl->getModuleContext();
   auto subMap = getContextSubstitutionMap(module,
                                           classDecl,
-                                          classDecl->getGenericEnvironment());
+                                          (useArchetypes
+                                           ? classDecl->getGenericEnvironment()
+                                           : nullptr));
   return superclassTy.subst(subMap);
 }
 
@@ -3220,7 +3222,8 @@ static Type getConcreteTypeForSuperclassTraversing(Type t) {
   return t;
 }
 
-Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass) {
+Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass,
+                                    bool useArchetypes) {
   Type t = getConcreteTypeForSuperclassTraversing(this);
 
   while (t) {
@@ -3233,7 +3236,7 @@ Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass) {
     if (nominalDecl == baseClass)
       return t;
 
-    t = t->getSuperclass();
+    t = t->getSuperclass(useArchetypes);
   }
   llvm_unreachable("no inheritance relationship between given classes");
 }

lib/Sema/CSApply.cpp

@@ -5484,9 +5484,11 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
   Type toInstanceType = toType;
 
   // Look through metatypes
-  while (fromInstanceType->is<AnyMetatypeType>() &&
+  while ((fromInstanceType->is<UnresolvedType>() ||
+          fromInstanceType->is<AnyMetatypeType>()) &&
          toInstanceType->is<ExistentialMetatypeType>()) {
-    fromInstanceType = fromInstanceType->castTo<AnyMetatypeType>()->getInstanceType();
+    if (!fromInstanceType->is<UnresolvedType>())
+      fromInstanceType = fromInstanceType->castTo<AnyMetatypeType>()->getInstanceType();
     toInstanceType = toInstanceType->castTo<ExistentialMetatypeType>()->getInstanceType();
   }
 

lib/Sema/ConstraintSystem.cpp

@@ -1053,31 +1053,6 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
   return { valueType, valueType };
 }
 
-static Type getInnermostConformingType(TypeChecker &TC, DeclContext *DC,
-                                       ProtocolDecl *protocol) {
-  do {
-    if (DC->isTypeContext()) {
-      if (protocol == DC->getAsProtocolOrProtocolExtensionContext())
-        return DC->mapTypeIntoContext(DC->getProtocolSelfType());
-
-      auto *NTD = DC->getAsNominalTypeOrNominalTypeExtensionContext();
-      auto type = NTD->getDeclaredType();
-
-      ConformanceCheckOptions options;
-      options |= ConformanceCheckFlags::InExpression;
-      options |= ConformanceCheckFlags::SuppressDependencyTracking;
-      options |= ConformanceCheckFlags::SkipConditionalRequirements;
-
-      auto result =
-          TC.conformsToProtocol(type, protocol, NTD->getDeclContext(), options);
-
-      if (result)
-        return DC->getDeclaredTypeInContext();
-    }
-  } while ((DC = DC->getParent()));
-
-  return nullptr;
-}
 /// Bind type variables for archetypes that are determined from
 /// context.
 ///
@@ -1093,10 +1068,10 @@ static Type getInnermostConformingType(TypeChecker &TC, DeclContext *DC,
 ///
 /// A final case we have to handle, even though it is invalid, is
 /// when a type is nested inside another protocol. We bind the
-/// protocol type variable for the protocol Self to its archetype
-/// in protocol context. This of course makes no sense, but we
-/// can't leave the type variable dangling, because then we crash
-/// later.
+/// protocol type variable for the protocol Self to an unresolved
+/// type, since it will conform to anything. This of course makes
+/// no sense, but we can't leave the type variable dangling,
+/// because then we crash later.
 ///
 /// If we ever do want to allow nominal types to be nested inside
 /// protocols, the key is to set their declared type to a
@@ -1117,43 +1092,43 @@ static void bindArchetypesFromContext(
 
   auto *genericEnv = cs.DC->getGenericEnvironmentOfContext();
 
+  auto bindContextArchetype = [&](Type paramTy, Type contextTy) {
+    auto found = replacements.find(cast<GenericTypeParamType>(
+                                     paramTy->getCanonicalType()));
+
+    // We might not have a type variable for this generic parameter
+    // because either we're opening up an UnboundGenericType,
+    // in which case we only want to infer the innermost generic
+    // parameters, or because this generic parameter was constrained
+    // away into a concrete type.
+    if (found != replacements.end()) {
+      auto typeVar = found->second;
+      cs.addConstraint(ConstraintKind::Bind, typeVar, contextTy,
+                       locatorPtr);
+    }
+  };
+
+  // Find the innermost non-type context.
   for (const auto *parentDC = outerDC;
        !parentDC->isModuleScopeContext();
        parentDC = parentDC->getParent()) {
-    if (parentDC->isTypeContext() &&
-        (parentDC == outerDC ||
-         !parentDC->getAsProtocolOrProtocolExtensionContext()))
+    if (parentDC->isTypeContext()) {
+      if (parentDC != outerDC && parentDC->getAsProtocolOrProtocolExtensionContext()) {
+        auto selfTy = parentDC->getSelfInterfaceType();
+        auto contextTy = cs.TC.Context.TheUnresolvedType;
+        bindContextArchetype(selfTy, contextTy);
+      }
       continue;
+    }
 
+    // If it's not generic, there's nothing to do.
     auto *genericSig = parentDC->getGenericSignatureOfContext();
     if (!genericSig)
       break;
 
     for (auto *paramTy : genericSig->getGenericParams()) {
-      auto found = replacements.find(cast<GenericTypeParamType>(
-                                       paramTy->getCanonicalType()));
-
-      // We might not have a type variable for this generic parameter
-      // because either we're opening up an UnboundGenericType,
-      // in which case we only want to infer the innermost generic
-      // parameters, or because this generic parameter was constrained
-      // away into a concrete type.
-      if (found != replacements.end()) {
-        Type contextTy;
-
-        if (genericEnv) {
-          contextTy = genericEnv->mapTypeIntoContext(paramTy);
-        } else {
-          auto *protocol = parentDC->getAsProtocolOrProtocolExtensionContext();
-          contextTy = getInnermostConformingType(cs.TC, cs.DC, protocol);
-        }
-
-        assert(contextTy);
-
-        auto typeVar = found->second;
-        cs.addConstraint(ConstraintKind::Bind, typeVar, contextTy,
-                         locatorPtr);
-      }
+      Type contextTy = genericEnv->mapTypeIntoContext(paramTy);
+      bindContextArchetype(paramTy, contextTy);
     }
 
     break;

lib/Sema/GenericTypeResolver.h

@@ -36,6 +36,8 @@ class GenericTypeResolver {
 public:
   virtual ~GenericTypeResolver();
 
+  virtual bool usesArchetypes() = 0;
+
   /// Resolve the given interface type to a contextual type if necessary.
   virtual Type mapTypeIntoContext(Type type) = 0;
 
@@ -66,6 +68,8 @@ class GenericTypeResolver {
 /// and only trivially resolves dependent member types.
 class DependentGenericTypeResolver : public GenericTypeResolver {
 public:
+  virtual bool usesArchetypes() { return false; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy,
@@ -93,6 +97,8 @@ class GenericTypeToArchetypeResolver : public GenericTypeResolver {
   explicit GenericTypeToArchetypeResolver(DeclContext *dc)
       : GenericEnv(dc->getGenericEnvironmentOfContext()) { }
 
+  virtual bool usesArchetypes() { return true; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy, DeclContext *DC,
@@ -111,6 +117,8 @@ class GenericTypeToArchetypeResolver : public GenericTypeResolver {
 /// protocols.
 class ProtocolRequirementTypeResolver : public GenericTypeResolver {
 public:
+  virtual bool usesArchetypes() { return false; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy, DeclContext *DC,
@@ -137,6 +145,8 @@ class CompleteGenericTypeResolver : public GenericTypeResolver {
 public:
   CompleteGenericTypeResolver(TypeChecker &tc, GenericSignature *genericSig);
 
+  virtual bool usesArchetypes() { return false; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy,

lib/Sema/TypeCheckDecl.cpp

@@ -603,23 +603,6 @@ static ArrayRef<EnumDecl *> getInheritedForCycleCheck(TypeChecker &tc,
   return { };
 }
 
-// Break the inheritance cycle for a protocol by removing all inherited
-// protocols.
-//
-// FIXME: Just remove the problematic inheritance?
-static void breakInheritanceCycle(ProtocolDecl *proto) {
-}
-
-/// Break the inheritance cycle for a class by removing its superclass.
-static void breakInheritanceCycle(ClassDecl *classDecl) {
-  classDecl->setSuperclass(Type());
-}
-
-/// Break the inheritance cycle for an enum by removing its raw type.
-static void breakInheritanceCycle(EnumDecl *enumDecl) {
-  enumDecl->setRawType(Type());
-}
-
 /// Check for circular inheritance.
 template<typename T>
 static void checkCircularity(TypeChecker &tc, T *decl,
@@ -649,9 +632,6 @@ static void checkCircularity(TypeChecker &tc, T *decl,
                   circularDiag,
                   path.back()->getName());
 
-      decl->setInvalid();
-      decl->setInterfaceType(ErrorType::get(tc.Context));
-      breakInheritanceCycle(decl);
       break;
     }
 
@@ -663,10 +643,6 @@ static void checkCircularity(TypeChecker &tc, T *decl,
                   declKind, (*i)->getName());
     }
 
-    // Set this declaration as invalid, then break the cycle somehow.
-    decl->setInvalid();
-    decl->setInterfaceType(ErrorType::get(tc.Context));
-    breakInheritanceCycle(decl);
     break;
   }
 
@@ -3374,6 +3350,7 @@ static void validateTypealiasType(TypeChecker &tc, TypeAliasDecl *typeAlias) {
   // of typealias underlying type e.g. `typealias F = () -> Int#^TOK^#`
   auto underlyingType = typeAlias->getUnderlyingTypeLoc();
   if (underlyingType.isNull()) {
+    typeAlias->getUnderlyingTypeLoc().setInvalidType(tc.Context);
     typeAlias->setInterfaceType(ErrorType::get(tc.Context));
     typeAlias->setInvalid();
     return;
@@ -3723,6 +3700,13 @@ void TypeChecker::validateDecl(ValueDecl *D) {
       return;
   }
 
+  // Validating the parent may have triggered validation of this declaration,
+  // so just return if that was the case.
+  if (D->hasValidationStarted()) {
+    assert(D->hasValidSignature());
+    return;
+  }
+
   if (Context.Stats)
     Context.Stats->getFrontendCounters().NumDeclsValidated++;
 
@@ -4743,8 +4727,14 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
       if (!typealias->getGenericParams()) {
         if (typealias->isBeingValidated()) return;
 
-        typealias->setIsBeingValidated();
-        SWIFT_DEFER { typealias->setIsBeingValidated(false); };
+        bool validated = typealias->hasValidationStarted();
+
+        if (!validated)
+          typealias->setIsBeingValidated();
+        SWIFT_DEFER {
+          if (!validated)
+            typealias->setIsBeingValidated(false);
+        };
 
         (void) typealias->getFormalAccess();
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1345,6 +1345,10 @@ static bool diagnoseOverrideForAvailability(ValueDecl *override,
 
 static bool recordOverride(TypeChecker &TC, ValueDecl *override,
                            ValueDecl *base, bool isKnownObjC) {
+  // This can happen with circular inheritance.
+  if (override == base)
+    return true;
+
   ASTContext &ctx = override->getASTContext();
   auto &diags = ctx.Diags;