diff --git a/include/swift/AST/GenericEnvironment.h b/include/swift/AST/GenericEnvironment.h
index 2a7e3279fec63..b5578631bb535 100644
--- a/include/swift/AST/GenericEnvironment.h
+++ b/include/swift/AST/GenericEnvironment.h
@@ -61,13 +61,13 @@ struct OpaqueEnvironmentData {
 };
 
 /// Extra data in a generic environment for an opened existential.
-struct OpenedExistentialEnvironmentData {
+struct ExistentialEnvironmentData {
   Type existential;
   UUID uuid;
 };
 
 /// Extra data in a generic environment for an opened pack element.
-struct OpenedElementEnvironmentData {
+struct ElementEnvironmentData {
   UUID uuid;
   CanGenericTypeParamType shapeClass;
 };
@@ -85,37 +85,38 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
         GenericEnvironment,
         SubstitutionMap,
         OpaqueEnvironmentData,
-        OpenedExistentialEnvironmentData,
-        OpenedElementEnvironmentData,
+        ExistentialEnvironmentData,
+        ElementEnvironmentData,
         Type> {
 public:
-  enum class Kind {
+  enum class Kind: uint8_t {
     /// A normal generic environment, determined only by its generic
     /// signature.
     Primary,
     /// A generic environment describing an opaque type archetype.
     Opaque,
     /// A generic environment describing an opened existential archetype.
-    OpenedExistential,
+    Existential,
     /// A generic environment describing an opened element type of a
     /// pack archetype inside a pack expansion expression.
-    OpenedElement,
+    Element,
   };
 
   class NestedTypeStorage;
 
 private:
-  mutable llvm::PointerIntPair<GenericSignature, 2, Kind> SignatureAndKind{
-      GenericSignature(), Kind::Primary};
+  GenericSignature sig;
   NestedTypeStorage *nestedTypeStorage = nullptr;
+  Kind kind;
+  bool canonical;
 
   friend TrailingObjects;
   friend OpaqueTypeArchetypeType;
 
   size_t numTrailingObjects(OverloadToken<SubstitutionMap>) const;
   size_t numTrailingObjects(OverloadToken<OpaqueEnvironmentData>) const;
-  size_t numTrailingObjects(OverloadToken<OpenedExistentialEnvironmentData>) const;
-  size_t numTrailingObjects(OverloadToken<OpenedElementEnvironmentData>) const;
+  size_t numTrailingObjects(OverloadToken<ExistentialEnvironmentData>) const;
+  size_t numTrailingObjects(OverloadToken<ElementEnvironmentData>) const;
   size_t numTrailingObjects(OverloadToken<Type>) const;
 
   /// Retrieve the array containing the context types associated with the
@@ -168,10 +169,13 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
 public:
   GenericSignature getGenericSignature() const {
-    return SignatureAndKind.getPointer();
+    return sig;
   }
 
-  Kind getKind() const { return SignatureAndKind.getInt(); }
+  Kind getKind() const { return kind; }
+
+  /// Returns if the archetypes from this environment are canonical types.
+  bool isCanonical() const { return canonical; }
 
   ArrayRef<GenericTypeParamType *> getGenericParams() const;
 
diff --git a/include/swift/AST/TypeNodes.def b/include/swift/AST/TypeNodes.def
index ec990d09eec8b..869a7cc7e99d5 100644
--- a/include/swift/AST/TypeNodes.def
+++ b/include/swift/AST/TypeNodes.def
@@ -176,7 +176,7 @@ TYPE(DynamicSelf, Type)
 ABSTRACT_TYPE(Substitutable, Type)
   ABSTRACT_TYPE(Archetype, SubstitutableType)
     ALWAYS_CANONICAL_TYPE(PrimaryArchetype, ArchetypeType)
-    ALWAYS_CANONICAL_TYPE(OpaqueTypeArchetype, ArchetypeType)
+    TYPE(OpaqueTypeArchetype, ArchetypeType)
     ABSTRACT_TYPE(LocalArchetype, ArchetypeType)
       ALWAYS_CANONICAL_TYPE(ExistentialArchetype, LocalArchetypeType)
       ALWAYS_CANONICAL_TYPE(ElementArchetype, LocalArchetypeType)
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
index 5a3ca5c7ff11f..aac8afe09a439 100644
--- a/include/swift/AST/Types.h
+++ b/include/swift/AST/Types.h
@@ -7009,7 +7009,7 @@ class ArchetypeType : public SubstitutableType,
   }
 protected:
   ArchetypeType(TypeKind Kind,
-                const ASTContext &C,
+                const ASTContext *C,
                 RecursiveTypeProperties properties,
                 Type InterfaceType,
                 ArrayRef<ProtocolDecl *> ConformsTo,
@@ -7088,7 +7088,8 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
   }
 
 private:
-  OpaqueTypeArchetypeType(GenericEnvironment *environment,
+  OpaqueTypeArchetypeType(const ASTContext *ctx,
+                          GenericEnvironment *environment,
                           RecursiveTypeProperties properties,
                           Type interfaceType,
                           ArrayRef<ProtocolDecl*> conformsTo,
@@ -7232,11 +7233,13 @@ class ExistentialArchetypeType final : public LocalArchetypeType,
   }
   
 private:
-  ExistentialArchetypeType(GenericEnvironment *environment, Type interfaceType,
-                      ArrayRef<ProtocolDecl *> conformsTo,
-                      Type superclass,
-                      LayoutConstraint layout,
-                      RecursiveTypeProperties properties);
+  ExistentialArchetypeType(const ASTContext *ctx,
+                           GenericEnvironment *environment,
+                           Type interfaceType,
+                           ArrayRef<ProtocolDecl *> conformsTo,
+                           Type superclass,
+                           LayoutConstraint layout,
+                           RecursiveTypeProperties properties);
 };
 BEGIN_CAN_TYPE_WRAPPER(ExistentialArchetypeType, LocalArchetypeType)
 END_CAN_TYPE_WRAPPER(ExistentialArchetypeType, LocalArchetypeType)
@@ -7309,7 +7312,7 @@ class ElementArchetypeType final : public LocalArchetypeType,
   }
   
 private:
-  ElementArchetypeType(const ASTContext &ctx,
+  ElementArchetypeType(const ASTContext *ctx,
                        GenericEnvironment *environment, Type interfaceType,
                        ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
                        LayoutConstraint layout);
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 07b932e8c75f3..0eb5da09b369a 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -5731,7 +5731,8 @@ OpaqueTypeArchetypeType *OpaqueTypeArchetypeType::getNew(
   ASTContext &ctx = interfaceType->getASTContext();
   auto mem = ctx.Allocate(size, alignof(OpaqueTypeArchetypeType), arena);
   return ::new (mem)
-      OpaqueTypeArchetypeType(environment, properties, interfaceType,
+      OpaqueTypeArchetypeType(environment->isCanonical() ? &ctx : nullptr,
+                              environment, properties, interfaceType,
                               conformsTo, superclass, layout);
 }
 
@@ -5759,6 +5760,7 @@ CanTypeWrapper<ExistentialArchetypeType> ExistentialArchetypeType::getNew(
   void *mem = ctx.Allocate(size, alignof(ExistentialArchetypeType), arena);
 
   return CanExistentialArchetypeType(::new (mem) ExistentialArchetypeType(
+      environment->isCanonical() ? &ctx : nullptr,
       environment, interfaceType, conformsTo, superclass, layout,
       properties));
 }
@@ -6014,8 +6016,8 @@ GenericEnvironment *GenericEnvironment::forPrimary(GenericSignature signature) {
   unsigned numGenericParams = signature.getGenericParams().size();
   size_t bytes = totalSizeToAlloc<SubstitutionMap,
                                   OpaqueEnvironmentData,
-                                  OpenedExistentialEnvironmentData,
-                                  OpenedElementEnvironmentData, Type>(
+                                  ExistentialEnvironmentData,
+                                  ElementEnvironmentData, Type>(
       0, 0, 0, 0, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
   return new (mem) GenericEnvironment(signature);
@@ -6025,11 +6027,6 @@ GenericEnvironment *GenericEnvironment::forPrimary(GenericSignature signature) {
 /// outer substitutions.
 GenericEnvironment *GenericEnvironment::forOpaqueType(
     OpaqueTypeDecl *opaque, SubstitutionMap subs) {
-  // TODO: We could attempt to preserve type sugar in the substitution map.
-  // Currently archetypes are assumed to be always canonical in many places,
-  // though, so doing so would require fixing those places.
-  subs = subs.getCanonical();
-
   auto &ctx = opaque->getASTContext();
 
   auto properties = ArchetypeType::archetypeProperties(
@@ -6044,9 +6041,9 @@ GenericEnvironment *GenericEnvironment::forOpaqueType(
     auto signature = opaque->getOpaqueInterfaceGenericSignature();
     unsigned numGenericParams = signature.getGenericParams().size();
     size_t bytes = totalSizeToAlloc<SubstitutionMap,
-                                  OpaqueEnvironmentData,
-                                    OpenedExistentialEnvironmentData,
-                                    OpenedElementEnvironmentData, Type>(
+                                    OpaqueEnvironmentData,
+                                    ExistentialEnvironmentData,
+                                    ElementEnvironmentData, Type>(
         1, 1, 0, 0, numGenericParams);
     void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment), arena);
     env = new (mem) GenericEnvironment(signature, opaque, subs);
@@ -6108,8 +6105,8 @@ GenericEnvironment::forOpenedExistential(
   unsigned numGenericParams = signature.getGenericParams().size();
   size_t bytes = totalSizeToAlloc<SubstitutionMap,
                                   OpaqueEnvironmentData,
-                                  OpenedExistentialEnvironmentData,
-                                  OpenedElementEnvironmentData, Type>(
+                                  ExistentialEnvironmentData,
+                                  ElementEnvironmentData, Type>(
       1, 0, 1, 0, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
   auto *genericEnv =
@@ -6146,8 +6143,8 @@ GenericEnvironment::forOpenedElement(GenericSignature signature,
   unsigned numOpenedParams = signature.getInnermostGenericParams().size();
   size_t bytes = totalSizeToAlloc<SubstitutionMap,
                                   OpaqueEnvironmentData,
-                                  OpenedExistentialEnvironmentData,
-                                  OpenedElementEnvironmentData,
+                                  ExistentialEnvironmentData,
+                                  ElementEnvironmentData,
                                   Type>(
       1, 0, 0, 1, numGenericParams + numOpenedParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
index 80cacbdefbd97..672ece35e33f2 100644
--- a/lib/AST/ASTPrinter.cpp
+++ b/lib/AST/ASTPrinter.cpp
@@ -3634,16 +3634,6 @@ void PrintAST::visitTypeAliasDecl(TypeAliasDecl *decl) {
 
   if (ShouldPrint) {
     Printer << " = ";
-    // FIXME: An inferred associated type witness type alias may reference
-    // an opaque type, but OpaqueTypeArchetypes are always canonicalized
-    // so lose type sugar for generic params. Bind the generic signature so
-    // we can map params back into the generic signature and print them
-    // correctly.
-    //
-    // Remove this when we have a way to represent non-canonical archetypes
-    // preserving sugar.
-    PrintOptions::OverrideScope scope(Options);
-    OVERRIDE_PRINT_OPTION(scope, GenericSig, decl->getGenericSignature().getPointer());
     printTypeLoc(TypeLoc(decl->getUnderlyingTypeRepr(), Ty));
     printDeclGenericRequirements(decl);
   }
@@ -7500,11 +7490,6 @@ class TypePrinter : public TypeVisitor<TypePrinter, void, NonRecursivePrintOptio
       if (auto existential = constraint->getAs<ExistentialType>())
         constraint = existential->getConstraintType();
 
-      // Opaque archetype substitutions are always canonical, so re-sugar the
-      // constraint type using the owning declaration's generic parameter names.
-      if (genericSig)
-        constraint = genericSig->getSugaredType(constraint);
-
       visit(constraint);
       return;
     }
diff --git a/lib/AST/CaptureInfo.cpp b/lib/AST/CaptureInfo.cpp
index f2b12c76ff843..4a88879a085a9 100644
--- a/lib/AST/CaptureInfo.cpp
+++ b/lib/AST/CaptureInfo.cpp
@@ -77,7 +77,7 @@ CaptureInfo::CaptureInfo(ASTContext &ctx, ArrayRef<CapturedValue> captures,
   // This is the only kind of local generic environment we can capture right now.
 #ifndef NDEBUG
   for (auto *env : genericEnv) {
-    assert(env->getKind() == GenericEnvironment::Kind::OpenedElement);
+    assert(env->getKind() == GenericEnvironment::Kind::Element);
   }
 #endif
 
diff --git a/lib/AST/GenericEnvironment.cpp b/lib/AST/GenericEnvironment.cpp
index 10b54f89806b9..f3633002506b8 100644
--- a/lib/AST/GenericEnvironment.cpp
+++ b/lib/AST/GenericEnvironment.cpp
@@ -31,8 +31,8 @@ size_t GenericEnvironment::numTrailingObjects(
   case Kind::Primary:
     return 0;
 
-  case Kind::OpenedExistential:
-  case Kind::OpenedElement:
+  case Kind::Existential:
+  case Kind::Element:
   case Kind::Opaque:
     return 1;
   }
@@ -42,8 +42,8 @@ size_t GenericEnvironment::numTrailingObjects(
     OverloadToken<OpaqueEnvironmentData>) const {
   switch (getKind()) {
   case Kind::Primary:
-  case Kind::OpenedExistential:
-  case Kind::OpenedElement:
+  case Kind::Existential:
+  case Kind::Element:
     return 0;
 
   case Kind::Opaque:
@@ -52,34 +52,34 @@ size_t GenericEnvironment::numTrailingObjects(
 }
 
 size_t GenericEnvironment::numTrailingObjects(
-    OverloadToken<OpenedExistentialEnvironmentData>) const {
+    OverloadToken<ExistentialEnvironmentData>) const {
   switch (getKind()) {
   case Kind::Primary:
   case Kind::Opaque:
-  case Kind::OpenedElement:
+  case Kind::Element:
     return 0;
 
-  case Kind::OpenedExistential:
+  case Kind::Existential:
     return 1;
   }
 }
 
 size_t GenericEnvironment::numTrailingObjects(
-    OverloadToken<OpenedElementEnvironmentData>) const {
+    OverloadToken<ElementEnvironmentData>) const {
   switch (getKind()) {
   case Kind::Primary:
   case Kind::Opaque:
-  case Kind::OpenedExistential:
+  case Kind::Existential:
     return 0;
 
-  case Kind::OpenedElement:
+  case Kind::Element:
     return 1;
   }
 }
 
 size_t GenericEnvironment::numTrailingObjects(OverloadToken<Type>) const {
   return getGenericParams().size()
-       + (getKind() == Kind::OpenedElement ? getNumOpenedPackParams() : 0);
+       + (getKind() == Kind::Element ? getNumOpenedPackParams() : 0);
 }
 
 /// Retrieve the array containing the context types associated with the
@@ -99,7 +99,7 @@ ArrayRef<Type> GenericEnvironment::getContextTypes() const {
 }
 
 unsigned GenericEnvironment::getNumOpenedPackParams() const {
-  assert(getKind() == Kind::OpenedElement);
+  assert(getKind() == Kind::Element);
   return getGenericSignature().getInnermostGenericParams().size();
 }
 
@@ -130,24 +130,24 @@ OpaqueTypeDecl *GenericEnvironment::getOpaqueTypeDecl() const {
 
 CanGenericTypeParamType
 GenericEnvironment::getOpenedElementShapeClass() const {
-  assert(getKind() == Kind::OpenedElement);
-  auto environmentData = getTrailingObjects<OpenedElementEnvironmentData>();
+  assert(getKind() == Kind::Element);
+  auto environmentData = getTrailingObjects<ElementEnvironmentData>();
   return environmentData->shapeClass;
 }
 
 Type GenericEnvironment::getOpenedExistentialType() const {
-  assert(getKind() == Kind::OpenedExistential);
-  return getTrailingObjects<OpenedExistentialEnvironmentData>()->existential;
+  assert(getKind() == Kind::Existential);
+  return getTrailingObjects<ExistentialEnvironmentData>()->existential;
 }
 
 UUID GenericEnvironment::getOpenedExistentialUUID() const {
-  assert(getKind() == Kind::OpenedExistential);
-  return getTrailingObjects<OpenedExistentialEnvironmentData>()->uuid;
+  assert(getKind() == Kind::Existential);
+  return getTrailingObjects<ExistentialEnvironmentData>()->uuid;
 }
 
 UUID GenericEnvironment::getOpenedElementUUID() const {
-  assert(getKind() == Kind::OpenedElement);
-  return getTrailingObjects<OpenedElementEnvironmentData>()->uuid;
+  assert(getKind() == Kind::Element);
+  return getTrailingObjects<ElementEnvironmentData>()->uuid;
 }
 
 void GenericEnvironment::forEachPackElementArchetype(
@@ -203,22 +203,21 @@ void GenericEnvironment::forEachPackElementBinding(
   assert(elementIt == packElements.end());
 }
 
-GenericEnvironment::GenericEnvironment(GenericSignature signature)
-  : SignatureAndKind(signature, Kind::Primary)
-{
+GenericEnvironment::GenericEnvironment(GenericSignature sig)
+  : sig(sig), kind(Kind::Primary), canonical(true) {
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
                           Type());
 }
 
 GenericEnvironment::GenericEnvironment(
-    GenericSignature signature,
+    GenericSignature sig,
     Type existential, SubstitutionMap subs, UUID uuid)
-  : SignatureAndKind(signature, Kind::OpenedExistential)
-{
+  : sig(sig), kind(Kind::Existential), canonical(subs.isCanonical()) {
+  ASSERT(canonical);
   *getTrailingObjects<SubstitutionMap>() = subs;
-  new (getTrailingObjects<OpenedExistentialEnvironmentData>())
-    OpenedExistentialEnvironmentData{ existential, uuid };
+  new (getTrailingObjects<ExistentialEnvironmentData>())
+    ExistentialEnvironmentData{ existential, uuid };
 
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
@@ -226,9 +225,8 @@ GenericEnvironment::GenericEnvironment(
 }
 
 GenericEnvironment::GenericEnvironment(
-      GenericSignature signature, OpaqueTypeDecl *opaque, SubstitutionMap subs)
-  : SignatureAndKind(signature, Kind::Opaque)
-{
+      GenericSignature sig, OpaqueTypeDecl *opaque, SubstitutionMap subs)
+  : sig(sig), kind(Kind::Opaque), canonical(subs.isCanonical()) {
   *getTrailingObjects<SubstitutionMap>() = subs;
   new (getTrailingObjects<OpaqueEnvironmentData>())
     OpaqueEnvironmentData{opaque};
@@ -238,15 +236,15 @@ GenericEnvironment::GenericEnvironment(
                           Type());
 }
 
-GenericEnvironment::GenericEnvironment(GenericSignature signature,
+GenericEnvironment::GenericEnvironment(GenericSignature sig,
                                        UUID uuid,
                                        CanGenericTypeParamType shapeClass,
                                        SubstitutionMap outerSubs)
-  : SignatureAndKind(signature, Kind::OpenedElement)
-{
+  : sig(sig), kind(Kind::Element), canonical(true) {
+  // FIXME: ASSERT(outerSubs.isCanonical());
   *getTrailingObjects<SubstitutionMap>() = outerSubs;
-  new (getTrailingObjects<OpenedElementEnvironmentData>())
-    OpenedElementEnvironmentData{uuid, shapeClass};
+  new (getTrailingObjects<ElementEnvironmentData>())
+    ElementEnvironmentData{uuid, shapeClass};
 
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
@@ -255,9 +253,9 @@ GenericEnvironment::GenericEnvironment(GenericSignature signature,
   // Fill in the array of opened pack parameters.
   auto openedPacksBuffer = getOpenedPackParams();
   unsigned i = 0;
-  for (auto param : signature.getGenericParams()) {
+  for (auto param : sig.getGenericParams()) {
     if (!param->isParameterPack()) continue;
-    if (!signature->haveSameShape(param, shapeClass)) continue;
+    if (!sig->haveSameShape(param, shapeClass)) continue;
     openedPacksBuffer[i++] = param;
   }
   assert(i == openedPacksBuffer.size());
@@ -314,8 +312,8 @@ GenericEnvironment::maybeApplyOuterContextSubstitutions(Type type) const {
   case Kind::Primary:
     return type;
 
-  case Kind::OpenedExistential:
-  case Kind::OpenedElement:
+  case Kind::Existential:
+  case Kind::Element:
   case Kind::Opaque: {
     if (auto subs = getOuterSubstitutions()) {
       OuterSubstitutions replacer{subs,
@@ -446,7 +444,7 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
     break;
   }
 
-  case Kind::OpenedExistential: {
+  case Kind::Existential: {
     if (rootGP->getDepth() < genericSig->getMaxDepth()) {
       result = maybeApplyOuterContextSubstitutions(reducedType);
       break;
@@ -479,7 +477,7 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
     break;
   }
 
-  case Kind::OpenedElement: {
+  case Kind::Element: {
     if (rootGP->getDepth() < genericSig->getMaxDepth()) {
       result = maybeApplyOuterContextSubstitutions(reducedType);
       break;
@@ -610,7 +608,7 @@ struct FindElementArchetypeForOpenedPackParam {
 /// does not apply outer substitutions, which might not be what you expect.
 Type
 GenericEnvironment::mapContextualPackTypeIntoElementContext(Type type) const {
-  assert(getKind() == Kind::OpenedElement);
+  assert(getKind() == Kind::Element);
   assert(!type->hasTypeParameter() && "expected contextual type");
 
   if (!type->hasPackArchetype()) return type;
@@ -642,7 +640,7 @@ GenericEnvironment::mapContextualPackTypeIntoElementContext(CanType type) const
 /// substitutions, so it behaves like mapTypeIntoContext() in that respect.
 Type
 GenericEnvironment::mapPackTypeIntoElementContext(Type type) const {
-  assert(getKind() == Kind::OpenedElement);
+  assert(getKind() == Kind::Element);
   assert(!type->hasPackArchetype());
 
   if (!type->hasParameterPack()) return type;
diff --git a/lib/AST/LocalArchetypeRequirementCollector.cpp b/lib/AST/LocalArchetypeRequirementCollector.cpp
index 53c47d54340f3..7ccdf504a7cc3 100644
--- a/lib/AST/LocalArchetypeRequirementCollector.cpp
+++ b/lib/AST/LocalArchetypeRequirementCollector.cpp
@@ -135,14 +135,14 @@ GenericSignature swift::buildGenericSignatureWithCapturedEnvironments(
     case GenericEnvironment::Kind::Opaque:
       break;
 
-    case GenericEnvironment::Kind::OpenedExistential: {
+    case GenericEnvironment::Kind::Existential: {
       auto existentialTy = genericEnv->maybeApplyOuterContextSubstitutions(
           genericEnv->getOpenedExistentialType())
               ->mapTypeOutOfContext();
       collector.addOpenedExistential(existentialTy);
       continue;
     }
-    case GenericEnvironment::Kind::OpenedElement: {
+    case GenericEnvironment::Kind::Element: {
       collector.addOpenedElement(
           genericEnv->getOpenedElementShapeClass());
       continue;
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index a95cc1cdc5f5e..b7c37172bbd13 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -2023,6 +2023,14 @@ CanType TypeBase::computeCanonicalType() {
     Result = ErrorUnionType::get(ctx, newTerms).getPointer();
     break;
   }
+  case TypeKind::OpaqueTypeArchetype: {
+    auto *AT = cast<OpaqueTypeArchetypeType>(this);
+    Result = OpaqueTypeArchetypeType::get(
+        AT->getDecl(), AT->getInterfaceType(),
+        AT->getSubstitutions().getCanonical())
+          ->castTo<OpaqueTypeArchetypeType>();
+    break;
+  }
   case TypeKind::Integer: {
     auto intTy = cast<IntegerType>(this);
     APInt value = intTy->getValue();
@@ -3682,13 +3690,13 @@ int TupleType::getNamedElementId(Identifier I) const {
 }
 
 ArchetypeType::ArchetypeType(TypeKind Kind,
-                             const ASTContext &Ctx,
+                             const ASTContext *Ctx,
                              RecursiveTypeProperties properties,
                              Type InterfaceType,
                              ArrayRef<ProtocolDecl *> ConformsTo,
                              Type Superclass, LayoutConstraint Layout,
                              GenericEnvironment *Environment)
-  : SubstitutableType(Kind, &Ctx, properties),
+  : SubstitutableType(Kind, Ctx, properties),
     InterfaceType(InterfaceType),
     Environment(Environment)
 {
@@ -3822,7 +3830,7 @@ PrimaryArchetypeType::PrimaryArchetypeType(const ASTContext &Ctx,
                                      ArrayRef<ProtocolDecl *> ConformsTo,
                                      Type Superclass, LayoutConstraint Layout,
                                      RecursiveTypeProperties Properties)
-  : ArchetypeType(TypeKind::PrimaryArchetype, Ctx, Properties,
+  : ArchetypeType(TypeKind::PrimaryArchetype, &Ctx, Properties,
                   InterfaceType, ConformsTo, Superclass, Layout, GenericEnv)
 {
   assert(!InterfaceType->isParameterPack());
@@ -3858,12 +3866,13 @@ PrimaryArchetypeType::getNew(const ASTContext &Ctx,
 }
 
 OpaqueTypeArchetypeType::OpaqueTypeArchetypeType(
+    const ASTContext *ctx,
     GenericEnvironment *environment,
     RecursiveTypeProperties properties,
     Type interfaceType,
     ArrayRef<ProtocolDecl*> conformsTo,
     Type superclass, LayoutConstraint layout)
-  : ArchetypeType(TypeKind::OpaqueTypeArchetype, interfaceType->getASTContext(),
+  : ArchetypeType(TypeKind::OpaqueTypeArchetype, ctx,
                   properties, interfaceType, conformsTo, superclass, layout,
                   environment)
 {
@@ -3879,11 +3888,10 @@ SubstitutionMap OpaqueTypeArchetypeType::getSubstitutions() const {
 }
 
 ExistentialArchetypeType::ExistentialArchetypeType(
-    GenericEnvironment *environment, Type interfaceType,
+    const ASTContext *ctx, GenericEnvironment *environment, Type interfaceType,
     ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
     LayoutConstraint layout, RecursiveTypeProperties properties)
-  : LocalArchetypeType(TypeKind::ExistentialArchetype,
-                       interfaceType->getASTContext(), properties,
+  : LocalArchetypeType(TypeKind::ExistentialArchetype, ctx, properties,
                        interfaceType, conformsTo, superclass, layout,
                        environment)
 {
@@ -3895,7 +3903,7 @@ PackArchetypeType::PackArchetypeType(
     ArrayRef<ProtocolDecl *> ConformsTo, Type Superclass,
     LayoutConstraint Layout, PackShape Shape,
     RecursiveTypeProperties Properties)
-  : ArchetypeType(TypeKind::PackArchetype, Ctx, Properties,
+  : ArchetypeType(TypeKind::PackArchetype, &Ctx, Properties,
                     InterfaceType, ConformsTo, Superclass, Layout, GenericEnv) {
   assert(InterfaceType->isParameterPack());
   *getTrailingObjects<PackShape>() = Shape;
@@ -3947,7 +3955,7 @@ CanType PackArchetypeType::getReducedShape() {
 }
 
 ElementArchetypeType::ElementArchetypeType(
-    const ASTContext &Ctx, GenericEnvironment *GenericEnv, Type InterfaceType,
+    const ASTContext *Ctx, GenericEnvironment *GenericEnv, Type InterfaceType,
     ArrayRef<ProtocolDecl *> ConformsTo, Type Superclass,
     LayoutConstraint Layout)
     : LocalArchetypeType(TypeKind::ElementArchetype, Ctx,
@@ -3973,7 +3981,8 @@ CanTypeWrapper<ElementArchetypeType> ElementArchetypeType::getNew(
       alignof(ElementArchetypeType), arena);
 
   return CanElementArchetypeType(::new (mem) ElementArchetypeType(
-      ctx, environment, interfaceType, conformsTo, superclass, layout));
+      environment->isCanonical() ? &ctx : nullptr,
+      environment, interfaceType, conformsTo, superclass, layout));
 }
 
 UUID ElementArchetypeType::getOpenedElementID() const {
diff --git a/lib/AST/TypeSubstitution.cpp b/lib/AST/TypeSubstitution.cpp
index ab8d1ddfeaf5c..3eaf3cd55e5ab 100644
--- a/lib/AST/TypeSubstitution.cpp
+++ b/lib/AST/TypeSubstitution.cpp
@@ -407,7 +407,7 @@ TypeSubstituter::transformOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *opaqu
 
   // If we return an opaque archetype unchanged, recurse into its substitutions
   // as a special case.
-  if (known->getCanonicalType() == opaque->getCanonicalType())
+  if (known.getPointer() == opaque)
     return std::nullopt; // Recursively process the substitutions of the
                          // opaque type archetype.
   return known;
diff --git a/lib/IRGen/GenPack.cpp b/lib/IRGen/GenPack.cpp
index 82d0de41cfbc9..9ffca6d8ca07c 100644
--- a/lib/IRGen/GenPack.cpp
+++ b/lib/IRGen/GenPack.cpp
@@ -1050,7 +1050,7 @@ llvm::Value *irgen::emitTypeMetadataPackElementRef(
 void irgen::bindOpenedElementArchetypesAtIndex(IRGenFunction &IGF,
                                                GenericEnvironment *environment,
                                                llvm::Value *index) {
-  assert(environment->getKind() == GenericEnvironment::Kind::OpenedElement);
+  ASSERT(environment->getKind() == GenericEnvironment::Kind::Element);
 
   // Record the generic type parameters of interest.
   llvm::SmallPtrSet<CanType, 2> openablePackParams;
diff --git a/lib/Sema/OpenedExistentials.cpp b/lib/Sema/OpenedExistentials.cpp
index 567eceea9e3a9..4a39cf9f1b69f 100644
--- a/lib/Sema/OpenedExistentials.cpp
+++ b/lib/Sema/OpenedExistentials.cpp
@@ -915,7 +915,7 @@ Type swift::typeEraseOpenedExistentialReference(
 
 Type swift::typeEraseOpenedArchetypesFromEnvironment(
     Type type, GenericEnvironment *env) {
-  assert(env->getKind() == GenericEnvironment::Kind::OpenedExistential);
+  ASSERT(env->getKind() == GenericEnvironment::Kind::Existential);
 
   return typeEraseExistentialSelfReferences(
       type,
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index b76da1d0234f5..d871389d146f9 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -1795,7 +1795,7 @@ void Serializer::writeASTBlockEntity(const GenericEnvironment *genericEnv) {
   assert(GenericEnvironmentsToSerialize.hasRef(genericEnv));
 
   switch (genericEnv->getKind()) {
-  case GenericEnvironment::Kind::OpenedExistential: {
+  case GenericEnvironment::Kind::Existential: {
     auto kind = GenericEnvironmentKind::OpenedExistential;
     auto existentialTypeID = addTypeRef(genericEnv->getOpenedExistentialType());
     auto parentSigID = addGenericSignatureRef(genericEnv->getGenericSignature());
@@ -1809,7 +1809,7 @@ void Serializer::writeASTBlockEntity(const GenericEnvironment *genericEnv) {
     return;
   }
 
-  case GenericEnvironment::Kind::OpenedElement: {
+  case GenericEnvironment::Kind::Element: {
     auto kind = GenericEnvironmentKind::OpenedElement;
     auto shapeClassID = addTypeRef(genericEnv->getOpenedElementShapeClass());
     auto parentSigID = addGenericSignatureRef(genericEnv->getGenericSignature());