[AST] Introduce ExistentialTypeRepr, which is the type repr for an

existential type spelled with `any`.

Author: hborla

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))
 
+ERROR(explicit_existential_not_supported,none,
+       "explicit 'any' not supported; use frontend flag "
+       "-enable-explicit-existential-types to enable this feature",
+       ())
+
 ERROR(nonisolated_let,none,
       "'nonisolated' is meaningless on 'let' declarations because "
       "they are immutable",

include/swift/AST/TypeRepr.h

@@ -1158,6 +1158,34 @@ class NamedOpaqueReturnTypeRepr : public TypeRepr {
   friend class TypeRepr;
 };
 
+/// A TypeRepr for an existential type spelled with \c any
+///
+/// Can appear anywhere a normal existential type would. This is
+/// purely a more explicit spelling for existential types.
+class ExistentialTypeRepr: public TypeRepr {
+  TypeRepr *Constraint;
+  SourceLoc AnyLoc;
+
+public:
+  ExistentialTypeRepr(SourceLoc anyLoc, TypeRepr *constraint)
+    : TypeRepr(TypeReprKind::Existential), Constraint(constraint),
+      AnyLoc(anyLoc) {}
+
+  TypeRepr *getConstraint() const { return Constraint; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::Existential;
+  }
+  static bool classof(const ExistentialTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const { return AnyLoc; }
+  SourceLoc getEndLocImpl() const { return Constraint->getEndLoc(); }
+  SourceLoc getLocImpl() const { return AnyLoc; }
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// TypeRepr for a user-specified placeholder (essentially, a user-facing
 /// representation of an anonymous type variable.
 ///
@@ -1285,6 +1313,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Composition:
   case TypeReprKind::OpaqueReturn:
   case TypeReprKind::NamedOpaqueReturn:
+  case TypeReprKind::Existential:
     return false;
   case TypeReprKind::SimpleIdent:
   case TypeReprKind::GenericIdent:

include/swift/AST/TypeReprNodes.def

@@ -55,6 +55,7 @@ TYPEREPR(Metatype, TypeRepr)
 TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
 TYPEREPR(NamedOpaqueReturn, TypeRepr)
+TYPEREPR(Existential, TypeRepr)
 TYPEREPR(Placeholder, TypeRepr)
 ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   TYPEREPR(InOut, SpecifierTypeRepr)

include/swift/AST/Types.h

@@ -6436,6 +6436,8 @@ 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())

lib/AST/ASTDumper.cpp

@@ -3095,6 +3095,12 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitExistentialTypeRepr(ExistentialTypeRepr *T) {
+    printCommon("type_existential");
+    printRec(T->getConstraint());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitPlaceholderTypeRepr(PlaceholderTypeRepr *T) {
     printCommon("type_placeholder");
     PrintWithColorRAII(OS, ParenthesisColor) << ')';

lib/AST/ASTWalker.cpp

@@ -1863,6 +1863,10 @@ bool Traversal::visitNamedOpaqueReturnTypeRepr(NamedOpaqueReturnTypeRepr *T) {
   return doIt(T->getBase());
 }
 
+bool Traversal::visitExistentialTypeRepr(ExistentialTypeRepr *T) {
+  return doIt(T->getConstraint());
+}
+
 bool Traversal::visitPlaceholderTypeRepr(PlaceholderTypeRepr *T) {
   return false;
 }

lib/AST/NameLookup.cpp

@@ -2319,6 +2319,7 @@ directReferencesForTypeRepr(Evaluator &evaluator,
 
   case TypeReprKind::OpaqueReturn:
   case TypeReprKind::NamedOpaqueReturn:
+  case TypeReprKind::Existential:
     return { };
 
   case TypeReprKind::Fixed:

lib/AST/TypeRepr.cpp

@@ -479,6 +479,12 @@ void OpaqueReturnTypeRepr::printImpl(ASTPrinter &Printer,
   printTypeRepr(Constraint, Printer, Opts);
 }
 
+void ExistentialTypeRepr::printImpl(ASTPrinter &Printer,
+                                    const PrintOptions &Opts) const {
+  Printer.printKeyword("any", Opts, /*Suffix=*/" ");
+  printTypeRepr(Constraint, Printer, Opts);
+}
+
 SourceLoc NamedOpaqueReturnTypeRepr::getStartLocImpl() const {
   return GenericParams->getLAngleLoc();
 }

lib/Sema/TypeCheckType.cpp

@@ -2058,6 +2058,16 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
                                        : ErrorType::get(getASTContext());
   }
 
+  case TypeReprKind::Existential: {
+    if (!getASTContext().LangOpts.EnableExplicitExistentialTypes &&
+        !(options & TypeResolutionFlags::SilenceErrors)) {
+      diagnose(repr->getLoc(), diag::explicit_existential_not_supported);
+    }
+
+    auto *existential = cast<ExistentialTypeRepr>(repr);
+    return resolveType(existential->getConstraint(), options);
+  }
+
   case TypeReprKind::NamedOpaqueReturn:
     return resolveType(cast<NamedOpaqueReturnTypeRepr>(repr)->getBase(),
                        options);