Lift getCanonicalTypeInContext up to GenericSignature

Author: CodaFi

include/swift/AST/GenericSignature.h

@@ -209,6 +209,10 @@ class GenericSignature {
   SmallVector<Requirement, 4>
   requirementsNotSatisfiedBy(GenericSignature otherSig) const;
 
+  /// Return the canonical version of the given type under this generic
+  /// signature.
+  CanType getCanonicalTypeInContext(Type type) const;
+
   /// Check invariants.
   void verify() const;
 };
@@ -381,10 +385,6 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   bool isRequirementSatisfied(
       Requirement requirement, bool allowMissing = false) const;
 
-  /// Return the canonical version of the given type under this generic
-  /// signature.
-  CanType getCanonicalTypeInContext(Type type) const;
-
   bool isCanonicalTypeInContext(Type type) const;
   bool isCanonicalTypeInContext(Type type,
                                 GenericSignatureBuilder &builder) const;
@@ -470,6 +470,10 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// equivalent to or a subset of the generic parameters in this signature.
   SmallVector<Requirement, 4>
   requirementsNotSatisfiedBy(GenericSignature otherSig) const;
+
+  /// Return the canonical version of the given type under this generic
+  /// signature.
+  CanType getCanonicalTypeInContext(Type type) const;
 };
 
 void simple_display(raw_ostream &out, GenericSignature sig);

include/swift/SIL/AbstractionPattern.h

@@ -530,7 +530,7 @@ class AbstractionPattern {
     OrigType = origType;
     GenericSig = CanGenericSignature();
     if (OrigType->hasTypeParameter()) {
-      assert(OrigType == signature->getCanonicalTypeInContext(origType));
+      assert(OrigType == signature.getCanonicalTypeInContext(origType));
       GenericSig = signature;
     }
   }

include/swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h

@@ -135,8 +135,8 @@ class DifferentiableActivityInfo {
   bool hasTangentSpace(SILValue value) {
     auto type = value->getType().getASTType();
     // Remap archetypes in the derivative generic signature, if it exists.
-    if (derivativeGenericSignature && type->hasArchetype()) {
-      type = derivativeGenericSignature->getCanonicalTypeInContext(
+    if (type->hasArchetype()) {
+      type = derivativeGenericSignature.getCanonicalTypeInContext(
           type->mapTypeOutOfContext());
     }
     // Look up conformance in the current module.

lib/AST/GenericSignature.cpp

@@ -1081,6 +1081,15 @@ bool GenericSignatureImpl::isCanonicalTypeInContext(
   });
 }
 
+CanType GenericSignature::getCanonicalTypeInContext(Type type) const {
+  // The null generic signature has no requirements so cannot influence the
+  // structure of the can type computed here.
+  if (isNull()) {
+    return type->getCanonicalType();
+  }
+  return getPointer()->getCanonicalTypeInContext(type);
+}
+
 CanType GenericSignatureImpl::getCanonicalTypeInContext(Type type) const {
   type = type->getCanonicalType();
 

lib/AST/SubstitutionMap.cpp

@@ -295,7 +295,7 @@ Type SubstitutionMap::lookupSubstitution(CanSubstitutableType type) const {
 
   // The generic parameter may not be canonical. Retrieve the canonical
   // type, which will be dependent.
-  CanType canonicalType = genericSig->getCanonicalTypeInContext(genericParam);
+  CanType canonicalType = genericSig.getCanonicalTypeInContext(genericParam);
 
   // If nothing changed, we don't have a replacement.
   if (canonicalType == type) return Type();

lib/AST/Type.cpp

@@ -1450,10 +1450,7 @@ CanType TypeBase::computeCanonicalType() {
 }
 
 CanType TypeBase::getCanonicalType(GenericSignature sig) {
-  if (!sig)
-    return getCanonicalType();
-
-  return sig->getCanonicalTypeInContext(this);
+  return sig.getCanonicalTypeInContext(this);
 }
 
 TypeBase *TypeBase::reconstituteSugar(bool Recursive) {
@@ -1904,7 +1901,7 @@ class IsBindableVisitor
 
         // Collect requirements from the conformance not satisfied by the
         // original declaration.
-        for (auto reqt : conformanceSig->requirementsNotSatisfiedBy(genericSig)) {
+        for (auto reqt : conformanceSig.requirementsNotSatisfiedBy(genericSig)) {
           LLVM_DEBUG(llvm::dbgs() << "\n- adds requirement\n";
                      reqt.dump(llvm::dbgs()));
 

lib/SIL/IR/AbstractionPattern.cpp

@@ -47,13 +47,9 @@ TypeConverter::getAbstractionPattern(AbstractStorageDecl *decl,
 
 AbstractionPattern
 TypeConverter::getAbstractionPattern(SubscriptDecl *decl, bool isNonObjC) {
-  auto type = decl->getElementInterfaceType()->getCanonicalType();
-  CanGenericSignature genericSig;
-  if (auto sig = decl->getGenericSignatureOfContext()) {
-    genericSig = sig.getCanonicalSignature();
-    type = sig->getCanonicalTypeInContext(type);
-  }
-  return AbstractionPattern(genericSig, type);
+  auto sig = decl->getGenericSignatureOfContext().getCanonicalSignature();
+  auto type = sig.getCanonicalTypeInContext(decl->getElementInterfaceType());
+  return AbstractionPattern(sig, type);
 }
 
 static const clang::Type *getClangType(const clang::Decl *decl) {
@@ -78,30 +74,27 @@ static Bridgeability getClangDeclBridgeability(const clang::Decl *decl) {
 
 AbstractionPattern
 TypeConverter::getAbstractionPattern(VarDecl *var, bool isNonObjC) {
-  CanType swiftType = var->getInterfaceType()
-                         ->getCanonicalType();
-
-  CanGenericSignature genericSig;
-  if (auto sig = var->getDeclContext()->getGenericSignatureOfContext()) {
-    genericSig = sig.getCanonicalSignature();
-    swiftType = genericSig->getCanonicalTypeInContext(swiftType);
-  }
+  auto sig = var->getDeclContext()
+                 ->getGenericSignatureOfContext()
+                 .getCanonicalSignature();
+  auto swiftType = sig.getCanonicalTypeInContext(var->getInterfaceType());
 
   if (isNonObjC)
-    return AbstractionPattern(genericSig, swiftType);
+    return AbstractionPattern(sig, swiftType);
 
   if (auto clangDecl = var->getClangDecl()) {
     auto clangType = getClangType(clangDecl);
     auto contextType = var->getDeclContext()->mapTypeIntoContext(swiftType);
-    swiftType = getLoweredBridgedType(
-        AbstractionPattern(genericSig, swiftType, clangType),
-        contextType, getClangDeclBridgeability(clangDecl),
-        SILFunctionTypeRepresentation::CFunctionPointer,
-        TypeConverter::ForMemory)->getCanonicalType();
-    return AbstractionPattern(genericSig, swiftType, clangType);
+    swiftType =
+        getLoweredBridgedType(AbstractionPattern(sig, swiftType, clangType),
+                              contextType, getClangDeclBridgeability(clangDecl),
+                              SILFunctionTypeRepresentation::CFunctionPointer,
+                              TypeConverter::ForMemory)
+            ->getCanonicalType();
+    return AbstractionPattern(sig, swiftType, clangType);
   }
 
-  return AbstractionPattern(genericSig, swiftType);
+  return AbstractionPattern(sig, swiftType);
 }
 
 AbstractionPattern TypeConverter::getAbstractionPattern(EnumElementDecl *decl) {
@@ -113,15 +106,12 @@ AbstractionPattern TypeConverter::getAbstractionPattern(EnumElementDecl *decl) {
          "Optional.Some does not have a unique abstraction pattern because "
          "optionals are re-abstracted");
 
-  CanType type = decl->getArgumentInterfaceType()->getCanonicalType();
-
-  CanGenericSignature genericSig;
-  if (auto sig = decl->getParentEnum()->getGenericSignatureOfContext()) {
-    genericSig = sig.getCanonicalSignature();
-    type = genericSig->getCanonicalTypeInContext(type);
-  }
+  auto sig = decl->getParentEnum()
+                 ->getGenericSignatureOfContext()
+                 .getCanonicalSignature();
+  auto type = sig.getCanonicalTypeInContext(decl->getArgumentInterfaceType());
 
-  return AbstractionPattern(genericSig, type);
+  return AbstractionPattern(sig, type);
 }
 
 AbstractionPattern::EncodedForeignInfo

lib/SIL/IR/TypeLowering.cpp

@@ -3402,11 +3402,11 @@ TypeConverter::getInterfaceBoxTypeForCapture(ValueDecl *captured,
 
   // Instantiate the layout with identity substitutions.
   auto subMap = SubstitutionMap::get(
-    signature,
-    [&](SubstitutableType *type) -> Type {
-      return signature->getCanonicalTypeInContext(type);
-    },
-    MakeAbstractConformanceForGenericType());
+      signature,
+      [&](SubstitutableType *type) -> Type {
+        return signature.getCanonicalTypeInContext(type);
+      },
+      MakeAbstractConformanceForGenericType());
 
   auto boxTy = SILBoxType::get(C, layout, subMap);
 #ifndef NDEBUG

lib/SILOptimizer/Differentiation/JVPCloner.cpp

@@ -352,8 +352,8 @@ class JVPCloner::Implementation final
   /// Find the tangent space of a given canonical type.
   Optional<TangentSpace> getTangentSpace(CanType type) {
     // Use witness generic signature to remap types.
-    if (auto witnessGenSig = witness->getDerivativeGenericSignature())
-      type = witnessGenSig->getCanonicalTypeInContext(type);
+    type = witness->getDerivativeGenericSignature().getCanonicalTypeInContext(
+        type);
     return type->getAutoDiffTangentSpace(
         LookUpConformanceInModule(getModule().getSwiftModule()));
   }

lib/SILOptimizer/Differentiation/PullbackCloner.cpp

@@ -211,8 +211,9 @@ class PullbackCloner::Implementation final
 
   Optional<TangentSpace> getTangentSpace(CanType type) {
     // Use witness generic signature to remap types.
-    if (auto witnessGenSig = getWitness()->getDerivativeGenericSignature())
-      type = witnessGenSig->getCanonicalTypeInContext(type);
+    type =
+        getWitness()->getDerivativeGenericSignature().getCanonicalTypeInContext(
+            type);
     return type->getAutoDiffTangentSpace(
         LookUpConformanceInModule(getModule().getSwiftModule()));
   }

lib/SILOptimizer/Utils/Generics.cpp

@@ -802,23 +802,14 @@ ReabstractionInfo::createSubstitutedType(SILFunction *OrigF,
   auto CanSpecializedGenericSig = SpecializedGenericSig.getCanonicalSignature();
 
   // First substitute concrete types into the existing function type.
-  CanSILFunctionType FnTy;
-  {
-    FnTy = OrigF->getLoweredFunctionType()
-                ->substGenericArgs(M, SubstMap, getResilienceExpansion())
-                ->getUnsubstitutedType(M);
-    // FIXME: Some of the added new requirements may not have been taken into
-    // account by the substGenericArgs. So, canonicalize in the context of the
-    // specialized signature.
-    if (CanSpecializedGenericSig)
-      FnTy = cast<SILFunctionType>(
-          CanSpecializedGenericSig->getCanonicalTypeInContext(FnTy));
-    else {
-      FnTy = cast<SILFunctionType>(FnTy->getCanonicalType());
-      assert(!FnTy->hasTypeParameter() && "Type parameters outside generic context?");
-    }
-  }
+  CanSILFunctionType FnTy =
+      cast<SILFunctionType>(CanSpecializedGenericSig.getCanonicalTypeInContext(
+          OrigF->getLoweredFunctionType()
+              ->substGenericArgs(M, SubstMap, getResilienceExpansion())
+              ->getUnsubstitutedType(M)));
   assert(FnTy);
+  assert((CanSpecializedGenericSig || !FnTy->hasTypeParameter()) &&
+         "Type parameters outside generic context?");
 
   // Use the new specialized generic signature.
   auto NewFnTy = SILFunctionType::get(
@@ -1439,8 +1430,7 @@ void FunctionSignaturePartialSpecializer::
     createGenericParamsForCalleeGenericParams() {
   for (auto GP : CalleeGenericSig.getGenericParams()) {
     auto CanTy = GP->getCanonicalType();
-    auto CanTyInContext =
-        CalleeGenericSig->getCanonicalTypeInContext(CanTy);
+    auto CanTyInContext = CalleeGenericSig.getCanonicalTypeInContext(CanTy);
     auto Replacement = CanTyInContext.subst(CalleeInterfaceToCallerArchetypeMap);
     LLVM_DEBUG(llvm::dbgs() << "\n\nChecking callee generic parameter:\n";
                CanTy->dump(llvm::dbgs()));

lib/Sema/TypeCheckAttr.cpp

@@ -4024,15 +4024,6 @@ static bool checkFunctionSignature(
     return false;
   }
 
-  // Map type into the required function type's generic signature, if it exists.
-  // This is significant when the required generic signature has same-type
-  // requirements while the candidate generic signature does not.
-  auto mapType = [&](Type type) {
-    if (!requiredGenSig)
-      return type->getCanonicalType();
-    return requiredGenSig->getCanonicalTypeInContext(type);
-  };
-
   // Check that parameter types match, disregarding labels.
   if (required->getNumParams() != candidateFnTy->getNumParams())
     return false;
@@ -4041,14 +4032,16 @@ static bool checkFunctionSignature(
                   [&](AnyFunctionType::Param x, AnyFunctionType::Param y) {
                     auto xInstanceTy = x.getOldType()->getMetatypeInstanceType();
                     auto yInstanceTy = y.getOldType()->getMetatypeInstanceType();
-                    return xInstanceTy->isEqual(mapType(yInstanceTy));
+                    return xInstanceTy->isEqual(
+                        requiredGenSig.getCanonicalTypeInContext(yInstanceTy));
                   }))
     return false;
 
   // If required result type is not a function type, check that result types
   // match exactly.
   auto requiredResultFnTy = dyn_cast<AnyFunctionType>(required.getResult());
-  auto candidateResultTy = mapType(candidateFnTy.getResult());
+  auto candidateResultTy =
+      requiredGenSig.getCanonicalTypeInContext(candidateFnTy.getResult());
   if (!requiredResultFnTy) {
     auto requiredResultTupleTy = dyn_cast<TupleType>(required.getResult());
     auto candidateResultTupleTy = dyn_cast<TupleType>(candidateResultTy);

lib/Sema/TypeCheckProtocolInference.cpp

@@ -827,7 +827,7 @@ Type AssociatedTypeInference::computeFixedTypeWitness(
       continue;
 
     auto structuralTy = DependentMemberType::get(selfTy, assocType->getName());
-    const auto ty = sig->getCanonicalTypeInContext(structuralTy);
+    const auto ty = sig.getCanonicalTypeInContext(structuralTy);
 
     // A dependent member type with an identical base and name indicates that
     // the protocol does not same-type constrain it in any way; move on to

lib/Sema/TypeCheckType.cpp

@@ -338,8 +338,8 @@ bool TypeResolution::areSameType(Type type1, Type type2) const {
         type2->isTypeParameter()) {
       return genericSig->areSameTypeParameterInContext(type1, type2);
     }
-    return genericSig->getCanonicalTypeInContext(type1)
-      == genericSig->getCanonicalTypeInContext(type2);
+    return genericSig.getCanonicalTypeInContext(type1) ==
+           genericSig.getCanonicalTypeInContext(type2);
   }
 
   // Otherwise, perform a structural check.