[TypeResolver] Resolve existential types to ExistentialType when

explicit existential types are enabled.

Note that existential metatypes still resolve to ExistentialMetatypeType,
but later this type can be replaced with ExistentialType(MetatypeType).

Author: hborla

lib/AST/ASTPrinter.cpp

@@ -4742,8 +4742,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     printWithParensIfNotSimple(T->getInstanceType());
 
     // We spell normal metatypes of existential types as .Protocol.
+    auto &ctx = T->getASTContext();
     if (isa<MetatypeType>(T) &&
-        T->getInstanceType()->isAnyExistentialType()) {
+        T->getInstanceType()->isAnyExistentialType() &&
+        !ctx.LangOpts.EnableExplicitExistentialTypes) {
       Printer << ".Protocol";
     } else {
       Printer << ".Type";

lib/Sema/TypeCheckGeneric.cpp

@@ -962,8 +962,16 @@ RequirementRequest::evaluate(Evaluator &evaluator,
                              WhereClauseOwner owner,
                              unsigned index,
                              TypeResolutionStage stage) const {
+  auto &reqRepr = getRequirement();
+
   // Figure out the type resolution.
-  auto options = TypeResolutionOptions(TypeResolverContext::GenericRequirement);
+  TypeResolverContext context;
+  if (reqRepr.getKind() == RequirementReprKind::SameType) {
+    context = TypeResolverContext::SameTypeRequirement;
+  } else {
+    context = TypeResolverContext::GenericRequirement;
+  }
+  auto options = TypeResolutionOptions(context);
   if (owner.dc->isInSpecializeExtensionContext())
     options |= TypeResolutionFlags::AllowUsableFromInline;
   Optional<TypeResolution> resolution;
@@ -981,7 +989,6 @@ RequirementRequest::evaluate(Evaluator &evaluator,
     break;
   }
 
-  auto &reqRepr = getRequirement();
   switch (reqRepr.getKind()) {
   case RequirementReprKind::TypeConstraint: {
     Type subject = resolution->resolveType(reqRepr.getSubjectRepr());

lib/Sema/TypeCheckType.cpp

@@ -1949,7 +1949,8 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
 
   // Strip the "is function input" bits unless this is a type that knows about
   // them.
-  if (!isa<SpecifierTypeRepr>(repr) && !isa<TupleTypeRepr>(repr) &&
+  if (options.is(TypeResolverContext::FunctionInput) &&
+      !isa<SpecifierTypeRepr>(repr) && !isa<TupleTypeRepr>(repr) &&
       !isa<AttributedTypeRepr>(repr) && !isa<FunctionTypeRepr>(repr) &&
       !isa<IdentTypeRepr>(repr) &&
       !isa<ImplicitlyUnwrappedOptionalTypeRepr>(repr)) {
@@ -2067,7 +2068,7 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
     }
 
     auto *existential = cast<ExistentialTypeRepr>(repr);
-    return resolveType(existential->getConstraint(), options);
+    return resolveExistentialType(existential, options);
   }
 
   case TypeReprKind::NamedOpaqueReturn:
@@ -3381,6 +3382,14 @@ TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
     return ErrorType::get(getASTContext());
   }
 
+  bool isConstraintType = (result->is<ProtocolType>() ||
+                           result->is<ProtocolCompositionType>());
+  if (isConstraintType &&
+      getASTContext().LangOpts.EnableExplicitExistentialTypes &&
+      options.isConstraintImplicitExistential()) {
+    return ExistentialType::get(result);
+  }
+
   // Hack to apply context-specific @escaping to a typealias with an underlying
   // function type.
   if (result->is<FunctionType>())
@@ -3560,6 +3569,9 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
   case TypeResolverContext::TypeAliasDecl:
   case TypeResolverContext::GenericTypeAliasDecl:
   case TypeResolverContext::GenericRequirement:
+  case TypeResolverContext::SameTypeRequirement:
+  case TypeResolverContext::ProtocolMetatypeBase:
+  case TypeResolverContext::MetatypeBase:
   case TypeResolverContext::ImmediateOptionalTypeArgument:
   case TypeResolverContext::InExpression:
   case TypeResolverContext::EditorPlaceholderExpr:
@@ -3702,7 +3714,8 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
   };
 
   for (auto tyR : repr->getTypes()) {
-    auto ty = resolveType(tyR, options.withoutContext());
+    auto ty = resolveType(tyR,
+        options.withContext(TypeResolverContext::GenericRequirement));
     if (ty->hasError()) return ty;
 
     auto nominalDecl = ty->getAnyNominal();
@@ -3739,19 +3752,27 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
 
   // In user-written types, AnyObject constraints always refer to the
   // AnyObject type in the standard library.
-  return ProtocolCompositionType::get(getASTContext(), Members,
-                                      /*HasExplicitAnyObject=*/false);
+  auto composition =
+      ProtocolCompositionType::get(getASTContext(), Members,
+                                   /*HasExplicitAnyObject=*/false);
+  if (getASTContext().LangOpts.EnableExplicitExistentialTypes &&
+      options.isConstraintImplicitExistential()) {
+    composition = ExistentialType::get(composition);
+  }
+  return composition;
 }
 
 NeverNullType
 TypeResolver::resolveExistentialType(ExistentialTypeRepr *repr,
                                      TypeResolutionOptions options) {
-  auto constraintType = resolveType(repr->getConstraint(), options);
+  auto constraintType = resolveType(repr->getConstraint(),
+      options.withContext(TypeResolverContext::GenericRequirement));
+  if (constraintType->is<ExistentialMetatypeType>())
+    return constraintType;
 
   auto anyStart = repr->getAnyLoc();
   auto anyEnd = Lexer::getLocForEndOfToken(getASTContext().SourceMgr, anyStart);
-  if (!constraintType->isExistentialType() &&
-      !constraintType->is<ExistentialMetatypeType>()) {
+  if (!constraintType->isExistentialType()) {
     diagnose(repr->getLoc(), diag::any_not_existential,
              constraintType->isTypeParameter(),
              constraintType)
@@ -3772,7 +3793,8 @@ TypeResolver::resolveExistentialType(ExistentialTypeRepr *repr,
 NeverNullType TypeResolver::resolveMetatypeType(MetatypeTypeRepr *repr,
                                                 TypeResolutionOptions options) {
   // The instance type of a metatype is always abstract, not SIL-lowered.
-  auto ty = resolveType(repr->getBase(), options.withoutContext());
+  auto ty = resolveType(repr->getBase(),
+      options.withContext(TypeResolverContext::MetatypeBase));
   if (ty->hasError()) {
     return ErrorType::get(getASTContext());
   }
@@ -3793,7 +3815,8 @@ NeverNullType TypeResolver::resolveMetatypeType(MetatypeTypeRepr *repr,
 NeverNullType
 TypeResolver::buildMetatypeType(MetatypeTypeRepr *repr, Type instanceType,
                                 Optional<MetatypeRepresentation> storedRepr) {
-  if (instanceType->isAnyExistentialType()) {
+  if (instanceType->isAnyExistentialType() &&
+      !instanceType->is<ExistentialType>()) {
     // TODO: diagnose invalid representations?
     return ExistentialMetatypeType::get(instanceType, storedRepr);
   } else {
@@ -3804,7 +3827,8 @@ TypeResolver::buildMetatypeType(MetatypeTypeRepr *repr, Type instanceType,
 NeverNullType TypeResolver::resolveProtocolType(ProtocolTypeRepr *repr,
                                                 TypeResolutionOptions options) {
   // The instance type of a metatype is always abstract, not SIL-lowered.
-  auto ty = resolveType(repr->getBase(), options.withoutContext());
+  auto ty = resolveType(repr->getBase(),
+      options.withContext(TypeResolverContext::ProtocolMetatypeBase));
   if (ty->hasError()) {
     return ErrorType::get(getASTContext());
   }

lib/Sema/TypeCheckType.h

@@ -125,6 +125,16 @@ enum class TypeResolverContext : uint8_t {
   /// Whether we are in a requirement of a generic declaration
   GenericRequirement,
 
+  /// Whether we are in a same-type requirement of a generic
+  /// declaration.
+  SameTypeRequirement,
+
+  /// Whether this is the base type of .Protocol
+  ProtocolMetatypeBase,
+
+  /// Whether this is the base type of .Type
+  MetatypeBase,
+
   /// Whether we are in a type argument for an optional
   ImmediateOptionalTypeArgument,
 
@@ -215,6 +225,9 @@ class TypeResolutionOptions {
     case Context::TypeAliasDecl:
     case Context::GenericTypeAliasDecl:
     case Context::GenericRequirement:
+    case Context::SameTypeRequirement:
+    case Context::ProtocolMetatypeBase:
+    case Context::MetatypeBase:
     case Context::ImmediateOptionalTypeArgument:
     case Context::AbstractFunctionDecl:
     case Context::Inherited:
@@ -224,6 +237,40 @@ class TypeResolutionOptions {
     llvm_unreachable("unhandled kind");
   }
 
+  /// Whether a generic constraint type is implicitly an
+  /// existential type in this context.
+  bool isConstraintImplicitExistential() const {
+    switch (context) {
+    case Context::Inherited:
+    case Context::ExtensionBinding:
+    case Context::TypeAliasDecl:
+    case Context::GenericTypeAliasDecl:
+    case Context::GenericRequirement:
+    case Context::MetatypeBase:
+      return false;
+    case Context::None:
+    case Context::InExpression:
+    case Context::ExplicitCastExpr:
+    case Context::ForEachStmt:
+    case Context::PatternBindingDecl:
+    case Context::EditorPlaceholderExpr:
+    case Context::ClosureExpr:
+    case Context::FunctionInput:
+    case Context::VariadicFunctionInput:
+    case Context::InoutFunctionInput:
+    case Context::FunctionResult:
+    case Context::SubscriptDecl:
+    case Context::EnumElementDecl:
+    case Context::EnumPatternPayload:
+    case Context::SameTypeRequirement:
+    case Context::ProtocolMetatypeBase:
+    case Context::ImmediateOptionalTypeArgument:
+    case Context::AbstractFunctionDecl:
+    case Context::CustomAttr:
+      return true;
+    }
+  }
+
   /// Determine whether all of the given options are set.
   bool contains(TypeResolutionFlags set) const {
     return !static_cast<bool>(unsigned(set) & ~unsigned(flags));
@@ -276,6 +323,13 @@ class TypeResolutionOptions {
     if (!preserveSIL) copy -= TypeResolutionFlags::SILType;
     return copy;
   }
+
+  inline
+  TypeResolutionOptions withContext(TypeResolverContext context) const {
+    auto copy = *this;
+    copy.setContext(context);
+    return copy;
+  }
 };
 
 /// A function reference used to "open" the given unbound generic type