Merge pull request #3045 from slavapestov/open-type-cleanup

Sema: Open type cleanup

Author: slavapestov

include/swift/AST/Decl.h

@@ -2771,18 +2771,12 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   Type DeclaredTy;
   Type DeclaredTyInContext;
 
-  void setDeclaredType(Type declaredTy) {
-    assert(DeclaredTy.isNull() && "Already set declared type");
-    DeclaredTy = declaredTy;
-  }
-
   NominalTypeDecl(DeclKind K, DeclContext *DC, Identifier name,
                   SourceLoc NameLoc,
                   MutableArrayRef<TypeLoc> inherited,
                   GenericParamList *GenericParams) :
     GenericTypeDecl(K, DC, name, NameLoc, inherited, GenericParams),
-    IterableDeclContext(IterableDeclContextKind::NominalTypeDecl),
-    DeclaredTy(nullptr)
+    IterableDeclContext(IterableDeclContextKind::NominalTypeDecl)
   {
     setGenericParams(GenericParams);
     NominalTypeDeclBits.HasDelayedMembers = false;

include/swift/AST/DeclContext.h

@@ -368,11 +368,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// Determine whether the innermost context is generic.
   bool isInnermostContextGeneric() const;
 
-  /// Determine the maximum depth of the current generic type context's generic
-  /// parameters. If the current context is not a generic type context, returns
-  /// the maximum depth of any generic parameter in this context.
-  unsigned getGenericTypeContextDepth() const;
-
   /// Get the most optimal resilience expansion for code in this context.
   /// If the body is able to be inlined into functions in other resilience
   /// domains, this ensures that only sufficiently-conservative access patterns

include/swift/AST/Requirement.h

@@ -55,7 +55,12 @@ class Requirement {
 public:
   /// Create a conformance or same-type requirement.
   Requirement(RequirementKind kind, Type first, Type second)
-    : FirstTypeAndKind(first, kind), SecondType(second) { }
+    : FirstTypeAndKind(first, kind), SecondType(second) {
+    if (kind != RequirementKind::WitnessMarker) {
+      assert(first);
+      assert(second);
+    }
+  }
 
   /// \brief Determine the kind of requirement.
   RequirementKind getKind() const { return FirstTypeAndKind.getInt(); }

include/swift/AST/Types.h

@@ -3403,7 +3403,7 @@ class DictionaryType : public TypeBase {
 
 /// ProtocolType - A protocol type describes an abstract interface implemented
 /// by another type.
-class ProtocolType : public NominalType {
+class ProtocolType : public NominalType, public llvm::FoldingSetNode {
 public:
   /// \brief Retrieve the type when we're referencing the given protocol.
   /// declaration.
@@ -3435,6 +3435,11 @@ class ProtocolType : public NominalType {
   static int compareProtocols(ProtocolDecl * const* PP1,
                               ProtocolDecl * const* PP2);
 
+  void Profile(llvm::FoldingSetNodeID &ID) {
+    Profile(ID, getDecl(), getParent());
+  }
+  static void Profile(llvm::FoldingSetNodeID &ID, ProtocolDecl *D, Type Parent);
+
 private:
   friend class NominalTypeDecl;
   ProtocolType(ProtocolDecl *TheDecl, const ASTContext &Ctx);

lib/AST/ASTContext.cpp

@@ -276,6 +276,7 @@ struct ASTContext::Implementation {
     llvm::FoldingSet<ClassType> ClassTypes;
     llvm::FoldingSet<UnboundGenericType> UnboundGenericTypes;
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
+    llvm::FoldingSet<ProtocolType> ProtocolTypes;
 
     llvm::DenseMap<std::pair<TypeBase *, DeclContext *>,
                    ArrayRef<Substitution>>
@@ -2621,6 +2622,8 @@ BoundGenericType *BoundGenericType::get(NominalTypeDecl *TheDecl,
   ASTContext &C = TheDecl->getDeclContext()->getASTContext();
   llvm::FoldingSetNodeID ID;
   RecursiveTypeProperties properties;
+  if (Parent)
+    properties |= Parent->getRecursiveProperties();
   BoundGenericType::Profile(ID, TheDecl, Parent, GenericArgs, properties);
 
   auto arena = getArena(properties);
@@ -3173,21 +3176,17 @@ SILFunctionType::SILFunctionType(GenericSignature *genericSig,
 
     for (auto param : getParameters()) {
       (void)param;
-      assert(!param.getType().findIf([](Type t) {
-        return t->is<ArchetypeType>()
-          && !t->castTo<ArchetypeType>()->getSelfProtocol();
-      }) && "interface type of generic type should not contain context archetypes");
+      assert(!param.getType()->hasArchetype()
+             && "interface type of generic type should not contain context archetypes");
     }
     for (auto result : getAllResults()) {
       (void)result;
-      assert(!result.getType().findIf([](Type t) {
-        return t->is<ArchetypeType>();
-      }) && "interface type of generic type should not contain context archetypes");
+      assert(!result.getType()->hasArchetype()
+             && "interface type of generic type should not contain context archetypes");
     }
     if (hasErrorResult()) {
-      assert(!getErrorResult().getType().findIf([](Type t) {
-        return t->is<ArchetypeType>();
-      }) && "interface type of generic type should not contain context archetypes");
+      assert(!getErrorResult().getType()->hasArchetype()
+             && "interface type of generic type should not contain context archetypes");
     }
   }
 
@@ -3360,18 +3359,39 @@ ImplicitlyUnwrappedOptionalType *ImplicitlyUnwrappedOptionalType::get(Type base)
 }
 
 ProtocolType *ProtocolType::get(ProtocolDecl *D, const ASTContext &C) {
-  if (auto declaredTy = D->getDeclaredType())
-    return declaredTy->castTo<ProtocolType>();
+  // Protocol types can never be nested inside other types, but we should
+  // model this anyway to fix some compiler crashes when computing
+  // substitutions on invalid code.
+  Type Parent;
+
+  llvm::FoldingSetNodeID id;
+  ProtocolType::Profile(id, D, Parent);
+
+  RecursiveTypeProperties properties;
+  if (Parent) properties |= Parent->getRecursiveProperties();
+  auto arena = getArena(properties);
+
+  void *insertPos = 0;
+  if (auto protoTy
+        = C.Impl.getArena(arena).ProtocolTypes.FindNodeOrInsertPos(id, insertPos))
+    return protoTy;
+
+  auto protoTy = new (C, arena) ProtocolType(D, C);
+  C.Impl.getArena(arena).ProtocolTypes.InsertNode(protoTy, insertPos);
 
-  auto protoTy = new (C, AllocationArena::Permanent) ProtocolType(D, C);
-  D->setDeclaredType(protoTy);
   return protoTy;
 }
 
 ProtocolType::ProtocolType(ProtocolDecl *TheDecl, const ASTContext &Ctx)
   : NominalType(TypeKind::Protocol, &Ctx, TheDecl, /*Parent=*/Type(),
                 RecursiveTypeProperties()) { }
 
+void ProtocolType::Profile(llvm::FoldingSetNodeID &ID, ProtocolDecl *D,
+                           Type Parent) {
+  ID.AddPointer(D);
+  ID.AddPointer(Parent.getPointer());
+}
+
 LValueType *LValueType::get(Type objectTy) {
   assert(!objectTy->is<ErrorType>() &&
          "cannot have ErrorType wrapped inside LValueType");

lib/AST/ArchetypeBuilder.cpp

@@ -2157,6 +2157,9 @@ addRequirements(
     ArchetypeBuilder::PotentialArchetype *pa,
     llvm::SmallPtrSet<ArchetypeBuilder::PotentialArchetype *, 16> &knownPAs,
     SmallVectorImpl<Requirement> &requirements) {
+
+  auto &ctx = builder.getASTContext();
+
   // If the potential archetype has been bound away to a concrete type,
   // it needs no requirements.
   if (pa->isConcreteType())
@@ -2181,8 +2184,8 @@ addRequirements(
 
   ProtocolType::canonicalizeProtocols(protocols);
   for (auto proto : protocols) {
-    requirements.push_back(Requirement(RequirementKind::Conformance,
-                                       type, proto->getDeclaredType()));
+    requirements.push_back(Requirement(RequirementKind::Conformance, type,
+                                       ProtocolType::get(proto, ctx)));
   }
 }
 

lib/AST/Decl.cpp

@@ -1684,11 +1684,9 @@ Type ValueDecl::getInterfaceType() const {
 
   if (auto assocType = dyn_cast<AssociatedTypeDecl>(this)) {
     auto proto = cast<ProtocolDecl>(getDeclContext());
-    (void)proto->getType(); // make sure we've computed the type.
-    // FIXME: the generic parameter types list should never be empty.
-    auto selfTy = proto->getInnermostGenericParamTypes().empty()
-                    ? proto->getProtocolSelf()->getType()
-                    : proto->getInnermostGenericParamTypes().back();
+    if (!proto->hasType())
+      proto->computeType(); // make sure we've computed the type.
+    auto selfTy = proto->getProtocolSelf()->getDeclaredType();
     auto &ctx = getASTContext();
     InterfaceTy = DependentMemberType::get(
                     selfTy,
@@ -1909,14 +1907,11 @@ void NominalTypeDecl::computeType() {
   Type parentTy = getDeclContext()->getDeclaredTypeInContext();
   ASTContext &ctx = getASTContext();
   if (auto proto = dyn_cast<ProtocolDecl>(this)) {
-    if (!getDeclaredType()) {
-      ProtocolType::get(proto, ctx);
-      assert(getDeclaredType());
-    }
+    DeclaredTy = ProtocolType::get(proto, ctx);
   } else if (getGenericParams()) {
-    setDeclaredType(UnboundGenericType::get(this, parentTy, ctx));
+    DeclaredTy = UnboundGenericType::get(this, parentTy, ctx);
   } else {
-    setDeclaredType(NominalType::get(this, parentTy, ctx));
+    DeclaredTy = NominalType::get(this, parentTy, ctx);
   }
 
   // Set the type.

lib/AST/DeclContext.cpp

@@ -431,25 +431,6 @@ bool DeclContext::isGenericContext() const {
   llvm_unreachable("illegal declcontext hierarchy");
 }
 
-/// Determine the maximum depth of the current generic type context's generic
-/// parameters. If the current context is not a generic type context, returns
-/// the maximum depth of any generic parameter in this context.
-unsigned DeclContext::getGenericTypeContextDepth() const {
-  unsigned depth = 0;
-  bool inTypeContext = true;
-  for (const auto *dc = this; dc; dc = dc->getParent()) {
-    // Starting from the innermost context that is not a type context, count
-    // all parent contexts that have generic parameters.
-    if (!dc->isTypeContext())
-      inTypeContext = false;
-
-    if (!inTypeContext && dc->isInnermostContextGeneric())
-      depth++;
-  }
-
-  return depth;
-}
-
 /// Get the most optimal resilience expansion for the body of this function.
 /// If the body is able to be inlined into functions in other resilience
 /// domains, this ensures that only sufficiently-conservative access patterns

lib/Sema/CSApply.cpp

@@ -1123,6 +1123,8 @@ namespace {
                        ConstraintLocatorBuilder locator,
                        Optional<Pattern*> typeFromPattern = None);
 
+    using LevelTy = llvm::PointerEmbeddedInt<unsigned, 2>;
+
     /// \brief Coerce the given expression (which is the argument to a call) to
     /// the given parameter type.
     ///
@@ -1136,8 +1138,6 @@ namespace {
     /// \param locator Locator used to describe where in this expression we are.
     ///
     /// \returns the coerced expression, which will have type \c ToType.
-    using LevelTy = llvm::PointerEmbeddedInt<unsigned, 2>;
-
     Expr *
     coerceCallArguments(Expr *arg, Type paramType,
                         llvm::PointerUnion<ApplyExpr *, LevelTy> applyOrLevel,

lib/Sema/CSRanking.cpp

@@ -450,7 +450,8 @@ static bool isProtocolExtensionAsSpecializedAs(TypeChecker &tc,
   // the second protocol extension.
   ConstraintSystem cs(tc, dc1, None);
   llvm::DenseMap<CanType, TypeVariableType *> replacements;
-  cs.openGeneric(dc2, sig2, false, dc2->getGenericTypeContextDepth(),
+  cs.openGeneric(dc2, dc2, sig2,
+                 /*skipProtocolSelfConstraint=*/false,
                  ConstraintLocatorBuilder(nullptr),
                  replacements);
 
@@ -571,14 +572,35 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
       auto locator = cs.getConstraintLocator(nullptr);
       // FIXME: Locator when anchored on a declaration.
       // Get the type of a reference to the second declaration.
-      Type openedType2 = cs.openType(type2, locator,
-                                     decl2->getInnermostDeclContext());
+      llvm::DenseMap<CanType, TypeVariableType *> unused;
+      Type openedType2;
+      if (auto *funcType = type2->getAs<AnyFunctionType>()) {
+        openedType2 = cs.openFunctionType(
+            funcType, locator,
+            /*replacements=*/unused,
+            decl2->getInnermostDeclContext(),
+            decl2->getDeclContext(),
+            /*skipProtocolSelfConstraint=*/false);
+      } else {
+        openedType2 = cs.openType(type2, locator, unused);
+      }
 
       // Get the type of a reference to the first declaration, swapping in
       // archetypes for the dependent types.
       llvm::DenseMap<CanType, TypeVariableType *> replacements;
       auto dc1 = decl1->getInnermostDeclContext();
-      Type openedType1 = cs.openType(type1, locator, replacements, dc1);
+      Type openedType1;
+      if (auto *funcType = type1->getAs<AnyFunctionType>()) {
+        openedType1 = cs.openFunctionType(
+            funcType, locator,
+            replacements,
+            dc1,
+            decl1->getDeclContext(),
+            /*skipProtocolSelfConstraint=*/false);
+      } else {
+        openedType1 = cs.openType(type1, locator, replacements);
+      }
+
       for (const auto &replacement : replacements) {
         if (auto mapped = 
                   ArchetypeBuilder::mapTypeIntoContext(dc1,