[Type Reconstruction] For now, reconstruct existential types without

explicit ExistentialType.

The ASTDemangler needs to produce ExistentialType based on context, not
unconditionally when producing a protocol composition. This is tricky
because existential types are mangled the same way as other protocol
references, e.g. in conformance requirements. For now, drop the explicit
existentials when reconstructing types.

Author: hborla

lib/AST/ASTDemangler.cpp

@@ -584,11 +584,15 @@ Type ASTBuilder::createProtocolCompositionType(
     members.push_back(protocol->getDeclaredInterfaceType());
   if (superclass && superclass->getClassOrBoundGenericClass())
     members.push_back(superclass);
+
+  // FIXME: When explicit existential types are enabled, protocol
+  // compositions should be wrapped in ExistentialType based on
+  // context, similar to how protocol compositions are resolved
+  // during type resolution. For example, protocol compositions
+  // in parameter types should be wrapped in ExistentialType, but
+  // protocol compositions on the right side of a conformance
+  // requirement should not.
   Type composition = ProtocolCompositionType::get(Ctx, members, isClassBound);
-  if (Ctx.LangOpts.EnableExplicitExistentialTypes &&
-      !(composition->isAny() || composition->isAnyObject())) {
-    composition = ExistentialType::get(composition);
-  }
   return composition;
 }
 

lib/IRGen/IRGenDebugInfo.cpp

@@ -900,6 +900,14 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
         Ty->dump(llvm::errs());
         abort();
       } else if (!Reconstructed->isEqual(Ty) &&
+                 // FIXME: Existential types are reconstructed without
+                 // an explicit ExistentialType wrapping the constraint.
+                 !(Ty->getASTContext().LangOpts.EnableExplicitExistentialTypes &&
+                   Ty.transform([](Type type) -> Type {
+                     if (auto existential = type->getAs<ExistentialType>())
+                       return existential->getConstraintType();
+                     return type;
+                   })->isEqual(Reconstructed)) &&
                  !EqualUpToClangTypes().check(Reconstructed, Ty)) {
         // [FIXME: Include-Clang-type-in-mangling] Remove second check
         llvm::errs() << "Incorrect reconstructed type for " << Result << "\n";