[Type System] Introduce a dedicated type to represent existential types.

hborla · hborla · commit 7bd3e83daa8d · 2021-12-10T12:07:37.000-08:00
The new type, called ExistentialType, is not yet used in type resolution.
Later, existential types written with `any` will resolve to this type, and
bare protocol names will resolve to this type depending on context.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -4618,6 +4618,11 @@ ERROR(unchecked_not_inheritance_clause,none,
 ERROR(unchecked_not_existential,none,
       "'unchecked' attribute cannot apply to non-protocol type %0", (Type))
 
+WARNING(unnecessary_any,none,
+         "'any' is redundant on type %0", (Type))
+ERROR(any_not_existential,none,
+       "'any' has no effect on %select{concrete type|type parameter}0 %1",
+       (bool, Type))
 ERROR(explicit_existential_not_supported,none,
        "explicit 'any' not supported; use frontend flag "
        "-enable-explicit-existential-types to enable this feature",
diff --git a/include/swift/AST/TypeDifferenceVisitor.h b/include/swift/AST/TypeDifferenceVisitor.h
@@ -328,6 +328,12 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
                                type1->getMembers(), type2->getMembers());
   }
 
+  bool visitExistentialType(CanExistentialType type1,
+                            CanExistentialType type2) {
+    return asImpl().visit(type1.getConstraintType(),
+                          type2.getConstraintType());
+  }
+
   bool visitLValueType(CanLValueType type1, CanLValueType type2) {
     return asImpl().visit(type1.getObjectType(), type2.getObjectType());
   }
diff --git a/include/swift/AST/TypeMatcher.h b/include/swift/AST/TypeMatcher.h
@@ -269,6 +269,20 @@ class TypeMatcher {
     TRIVIAL_CASE(SILBoxType)
     TRIVIAL_CASE(ProtocolCompositionType)
 
+    bool visitExistentialType(CanExistentialType firstExistential,
+                              Type secondType,
+                              Type sugaredFirstType) {
+      if (auto secondExistential = secondType->getAs<ExistentialType>()) {
+        return this->visit(firstExistential.getConstraintType(),
+                           secondExistential->getConstraintType(),
+                           sugaredFirstType->castTo<ExistentialType>()
+                               ->getConstraintType());
+      }
+
+      return mismatch(firstExistential.getPointer(), secondType,
+                      sugaredFirstType);
+    }
+
     bool visitLValueType(CanLValueType firstLValue, Type secondType,
                          Type sugaredFirstType) {
       if (auto secondLValue = secondType->getAs<LValueType>()) {
diff --git a/include/swift/AST/TypeNodes.def b/include/swift/AST/TypeNodes.def
@@ -162,6 +162,7 @@ ARTIFICIAL_TYPE(SILBlockStorage, Type)
 ARTIFICIAL_TYPE(SILBox, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
+TYPE(Existential, Type)
 TYPE(LValue, Type)
 TYPE(InOut, Type)
 UNCHECKED_TYPE(TypeVariable, Type)
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
@@ -1172,6 +1172,7 @@ class ExistentialTypeRepr: public TypeRepr {
       AnyLoc(anyLoc) {}
 
   TypeRepr *getConstraint() const { return Constraint; }
+  SourceLoc getAnyLoc() const { return AnyLoc; }
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Existential;
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -5199,6 +5199,42 @@ class ProtocolCompositionType final : public TypeBase,
 BEGIN_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
 END_CAN_TYPE_WRAPPER(ProtocolCompositionType, Type)
 
+/// An existential type, spelled with \c any .
+///
+/// In Swift 5 mode, a plain protocol name in type
+/// context is an implicit existential type.
+class ExistentialType final : public TypeBase {
+  Type ConstraintType;
+
+  ExistentialType(Type constraintType,
+                  const ASTContext *canonicalContext,
+                  RecursiveTypeProperties properties)
+      : TypeBase(TypeKind::Existential, canonicalContext, properties),
+        ConstraintType(constraintType) {}
+
+public:
+  static ExistentialType *get(Type constraint);
+
+  Type getConstraintType() const { return ConstraintType; }
+
+  bool requiresClass() const {
+    if (auto protocol = ConstraintType->getAs<ProtocolType>())
+      return protocol->requiresClass();
+
+    if (auto composition = ConstraintType->getAs<ProtocolCompositionType>())
+      return composition->requiresClass();
+
+    return false;
+  }
+
+  static bool classof(const TypeBase *type) {
+    return type->getKind() == TypeKind::Existential;
+  }
+};
+BEGIN_CAN_TYPE_WRAPPER(ExistentialType, Type)
+  PROXY_CAN_TYPE_SIMPLE_GETTER(getConstraintType)
+END_CAN_TYPE_WRAPPER(ExistentialType, Type)
+
 /// LValueType - An l-value is a handle to a physical object.  The
 /// type of that object uniquely determines the type of an l-value
 /// for it.
@@ -6154,7 +6190,9 @@ inline bool TypeBase::isAnyExistentialType() {
 }
 
 inline bool CanType::isExistentialTypeImpl(CanType type) {
-  return isa<ProtocolType>(type) || isa<ProtocolCompositionType>(type);
+  return (isa<ProtocolType>(type) ||
+          isa<ProtocolCompositionType>(type) ||
+          isa<ExistentialType>(type));
 }
 
 inline bool CanType::isAnyExistentialTypeImpl(CanType type) {
@@ -6167,6 +6205,8 @@ inline bool TypeBase::isClassExistentialType() {
     return pt->requiresClass();
   if (auto pct = dyn_cast<ProtocolCompositionType>(T))
     return pct->requiresClass();
+  if (auto existential = dyn_cast<ExistentialType>(T))
+    return existential->requiresClass();
   return false;
 }
 
@@ -6427,6 +6467,9 @@ inline bool TypeBase::hasSimpleTypeRepr() const {
   case TypeKind::ExistentialMetatype:
     return !cast<const AnyMetatypeType>(this)->hasRepresentation();
 
+  case TypeKind::Existential:
+    return false;
+
   case TypeKind::NestedArchetype:
     return cast<NestedArchetypeType>(this)->getParent()->hasSimpleTypeRepr();
       
@@ -6436,8 +6479,6 @@ inline bool TypeBase::hasSimpleTypeRepr() const {
 
   case TypeKind::ProtocolComposition: {
     // 'Any', 'AnyObject' and single protocol compositions are simple
-    // FIXME: single protocol compositions spelled with `any` are not
-    // simple.
     auto composition = cast<const ProtocolCompositionType>(this);
     auto memberCount = composition->getMembers().size();
     if (composition->hasExplicitAnyObject())
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -408,6 +408,7 @@ struct ASTContext::Implementation {
     llvm::DenseMap<std::pair<StructDecl*, Type>, StructType*> StructTypes;
     llvm::DenseMap<std::pair<ClassDecl*, Type>, ClassType*> ClassTypes;
     llvm::DenseMap<std::pair<ProtocolDecl*, Type>, ProtocolType*> ProtocolTypes;
+    llvm::DenseMap<Type, ExistentialType *> ExistentialTypes;
     llvm::FoldingSet<UnboundGenericType> UnboundGenericTypes;
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
     llvm::FoldingSet<ProtocolCompositionType> ProtocolCompositionTypes;
@@ -4093,6 +4094,21 @@ ProtocolType::ProtocolType(ProtocolDecl *TheDecl, Type Parent,
                            RecursiveTypeProperties properties)
   : NominalType(TypeKind::Protocol, &Ctx, TheDecl, Parent, properties) { }
 
+ExistentialType *ExistentialType::get(Type constraint) {
+  auto properties = constraint->getRecursiveProperties();
+  auto arena = getArena(properties);
+
+  auto &C = constraint->getASTContext();
+  auto &entry = C.getImpl().getArena(arena).ExistentialTypes[constraint];
+  if (entry)
+    return entry;
+
+  const ASTContext *canonicalContext = constraint->isCanonical() ? &C : nullptr;
+  return entry = new (C, arena) ExistentialType(constraint,
+                                                canonicalContext,
+                                                properties);
+}
+
 LValueType *LValueType::get(Type objectTy) {
   assert(!objectTy->is<LValueType>() && !objectTy->is<InOutType>() &&
          "cannot have 'inout' or @lvalue wrapped inside an @lvalue");
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3933,6 +3933,13 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
+    void visitExistentialType(ExistentialType *T,
+                              StringRef label) {
+      printCommon(label, "existential_type");
+      printRec(T->getConstraintType());
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     void visitLValueType(LValueType *T, StringRef label) {
       printCommon(label, "lvalue_type");
       printRec(T->getObjectType());
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -1251,6 +1251,11 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       return appendExistentialLayout(layout, sig, forDecl);
     }
 
+    case TypeKind::Existential: {
+      auto constraint = cast<ExistentialType>(tybase)->getConstraintType();
+      return appendType(constraint, sig, forDecl);
+    }
+
     case TypeKind::UnboundGeneric:
     case TypeKind::Class:
     case TypeKind::Enum:
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -5329,6 +5329,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  void visitExistentialType(ExistentialType *T) {
+    Printer << "any ";
+    visit(T->getConstraintType());
+  }
+
   void visitLValueType(LValueType *T) {
     Printer << "@lvalue ";
     visit(T->getObjectType());
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -1660,6 +1660,12 @@ static void extractDirectlyReferencedNominalTypes(
     return;
   }
 
+  if (auto existential = type->getAs<ExistentialType>()) {
+    extractDirectlyReferencedNominalTypes(
+        existential->getConstraintType(), decls);
+    return;
+  }
+
   llvm_unreachable("Not a type containing nominal types?");
 }
 
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -190,6 +190,9 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
     return cast<ProtocolType>(type)->requiresClass();
   case TypeKind::ProtocolComposition:
     return cast<ProtocolCompositionType>(type)->requiresClass();
+  case TypeKind::Existential:
+    return isReferenceTypeImpl(cast<ExistentialType>(type).getConstraintType(),
+                               sig, functionsCount);
 
   case TypeKind::UnboundGeneric:
     return isa<ClassDecl>(cast<UnboundGenericType>(type)->getDecl());
@@ -293,6 +296,12 @@ ExistentialLayout TypeBase::getExistentialLayout() {
 }
 
 ExistentialLayout CanType::getExistentialLayout() {
+  if (auto existential = dyn_cast<ExistentialType>(*this))
+    return existential->getConstraintType()->getExistentialLayout();
+
+  if (auto metatype = dyn_cast<ExistentialMetatypeType>(*this))
+    return metatype->getInstanceType()->getExistentialLayout();
+
   if (auto proto = dyn_cast<ProtocolType>(*this))
     return ExistentialLayout(proto);
 
@@ -1443,6 +1452,12 @@ CanType TypeBase::computeCanonicalType() {
     Result = Composition.getPointer();
     break;
   }
+  case TypeKind::Existential: {
+    auto *existential = cast<ExistentialType>(this);
+    auto constraint = existential->getConstraintType()->getCanonicalType();
+    Result = ExistentialType::get(constraint);
+    break;
+  }
   case TypeKind::ExistentialMetatype: {
     auto metatype = cast<ExistentialMetatypeType>(this);
     auto instanceType = metatype->getInstanceType()->getCanonicalType();
@@ -5236,6 +5251,19 @@ case TypeKind::Id:
       *this : InOutType::get(objectTy);
   }
 
+  case TypeKind::Existential: {
+    auto *existential = cast<ExistentialType>(base);
+    auto constraint = existential->getConstraintType().transformRec(fn);
+    if (!constraint || constraint->hasError())
+      return constraint;
+
+    if (constraint.getPointer() ==
+        existential->getConstraintType().getPointer())
+      return *this;
+
+    return ExistentialType::get(constraint);
+  }
+
   case TypeKind::ProtocolComposition: {
     auto pc = cast<ProtocolCompositionType>(base);
     SmallVector<Type, 4> substMembers;
@@ -5429,6 +5457,10 @@ ReferenceCounting TypeBase::getReferenceCounting() {
     return ReferenceCounting::Unknown;
   }
 
+  case TypeKind::Existential:
+    return cast<ExistentialType>(type)->getConstraintType()
+        ->getReferenceCounting();
+
   case TypeKind::Function:
   case TypeKind::GenericFunction:
   case TypeKind::SILFunction:
diff --git a/lib/AST/TypeWalker.cpp b/lib/AST/TypeWalker.cpp
@@ -163,6 +163,10 @@ class Traversal : public TypeVisitor<Traversal, bool>
     return false;
   }
 
+  bool visitExistentialType(ExistentialType *ty) {
+    return doIt(ty->getConstraintType());
+  }
+
   bool visitLValueType(LValueType *ty) {
     return doIt(ty->getObjectType());
   }
diff --git a/lib/IRGen/Fulfillment.cpp b/lib/IRGen/Fulfillment.cpp
@@ -99,6 +99,10 @@ static bool isLeafTypeMetadata(CanType type) {
   case TypeKind::ProtocolComposition:
     return false;
 
+  // Existential types have constraint types.
+  case TypeKind::Existential:
+    return false;
+
   // Metatypes have instance types.
   case TypeKind::Metatype:
   case TypeKind::ExistentialMetatype:
diff --git a/lib/IRGen/GenExistential.cpp b/lib/IRGen/GenExistential.cpp
@@ -1441,6 +1441,9 @@ static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM, CanType T) {
   }
 
   // Note: Protocol composition types are not nominal, but we name them anyway.
+  if (auto existential = T->getAs<ExistentialType>()) {
+    T = existential->getConstraintType()->getCanonicalType();
+  }
   llvm::StructType *type;
   if (isa<ProtocolType>(T))
     type = IGM.createNominalType(T);
@@ -1553,6 +1556,11 @@ TypeConverter::convertProtocolCompositionType(ProtocolCompositionType *T) {
   return createExistentialTypeInfo(IGM, CanType(T));
 }
 
+const TypeInfo *
+TypeConverter::convertExistentialType(ExistentialType *T) {
+  return createExistentialTypeInfo(IGM, CanType(T));
+}
+
 const TypeInfo *
 TypeConverter::convertExistentialMetatypeType(ExistentialMetatypeType *T) {
   assert(T->hasRepresentation() &&
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -2182,6 +2182,8 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
     return convertProtocolType(cast<ProtocolType>(ty));
   case TypeKind::ProtocolComposition:
     return convertProtocolCompositionType(cast<ProtocolCompositionType>(ty));
+  case TypeKind::Existential:
+    return convertExistentialType(cast<ExistentialType>(ty));
   case TypeKind::GenericTypeParam:
   case TypeKind::DependentMember:
     llvm_unreachable("can't convert dependent type");
diff --git a/lib/IRGen/GenType.h b/lib/IRGen/GenType.h
@@ -163,6 +163,7 @@ class TypeConverter {
   const TypeInfo *convertModuleType(ModuleType *T);
   const TypeInfo *convertProtocolType(ProtocolType *T);
   const TypeInfo *convertProtocolCompositionType(ProtocolCompositionType *T);
+  const TypeInfo *convertExistentialType(ExistentialType *T);
   const LoadableTypeInfo *convertBuiltinNativeObject();
   const LoadableTypeInfo *convertBuiltinUnknownObject();
   const LoadableTypeInfo *convertBuiltinBridgeObject();
diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp
@@ -1458,6 +1458,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
                                 Flags, MangledName);
     }
 
+    case TypeKind::Existential:
     case TypeKind::ProtocolComposition: {
       auto *Decl = DbgTy.getDecl();
       auto L = getFilenameAndLocation(*this, Decl);
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -1729,6 +1729,12 @@ namespace {
       return emitExistentialTypeMetadata(type, request);
     }
 
+    MetadataResponse
+    visitExistentialType(CanExistentialType type,
+                         DynamicMetadataRequest request) {
+      return emitExistentialTypeMetadata(type, request);
+    }
+
     MetadataResponse visitReferenceStorageType(CanReferenceStorageType type,
                                                DynamicMetadataRequest request) {
       llvm_unreachable("reference storage type should have been converted by "
diff --git a/lib/PrintAsObjC/DeclAndTypePrinter.cpp b/lib/PrintAsObjC/DeclAndTypePrinter.cpp
@@ -1830,6 +1830,12 @@ class DeclAndTypePrinter::Implementation
     visitExistentialType(PCT, optionalKind, /*isMetatype=*/false);
   }
 
+  void visitExistentialType(ExistentialType *ET,
+                            Optional<OptionalTypeKind> optionalKind) {
+    visitExistentialType(ET, optionalKind,
+        /*isMetatype=*/ET->getConstraintType()->is<AnyMetatypeType>());
+  }
+
   void visitExistentialMetatypeType(ExistentialMetatypeType *MT,
                                     Optional<OptionalTypeKind> optionalKind) {
     Type instanceTy = MT->getInstanceType();
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
diff --git a/lib/Sema/LookupVisibleDecls.cpp b/lib/Sema/LookupVisibleDecls.cpp
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
diff --git a/lib/Serialization/DeclTypeRecordNodes.def b/lib/Serialization/DeclTypeRecordNodes.def
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp

Original file line number	Diff line number	Diff line change
`@@ -328,6 +328,12 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {`
`328`	`328`	`type1->getMembers(), type2->getMembers());`
`329`	`329`	`}`
`330`	`330`
	`331`	`+ bool visitExistentialType(CanExistentialType type1,`
	`332`	`+ CanExistentialType type2) {`
	`333`	`+ return asImpl().visit(type1.getConstraintType(),`
	`334`	`+ type2.getConstraintType());`
	`335`	`+ }`
	`336`	`+`
`331`	`337`	`bool visitLValueType(CanLValueType type1, CanLValueType type2) {`
`332`	`338`	`return asImpl().visit(type1.getObjectType(), type2.getObjectType());`
`333`	`339`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5329,6 +5329,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {`
`5329`	`5329`	`}`
`5330`	`5330`	`}`
`5331`	`5331`
	`5332`	`+ void visitExistentialType(ExistentialType *T) {`
	`5333`	`+ Printer << "any ";`
	`5334`	`+ visit(T->getConstraintType());`
	`5335`	`+ }`
	`5336`	`+`
`5332`	`5337`	`void visitLValueType(LValueType *T) {`
`5333`	`5338`	`Printer << "@lvalue ";`
`5334`	`5339`	`visit(T->getObjectType());`