IRGen: Clean up some crusty old code

Author: slavapestov

lib/IRGen/GenMeta.cpp

@@ -2586,8 +2586,7 @@ void irgen::emitLazyTypeContextDescriptor(IRGenModule &IGM,
   eraseExistingTypeContextDescriptor(IGM, type);
 
   bool hasLayoutString = false;
-  auto lowered = getLoweredTypeInPrimaryContext(
-          IGM, type->getDeclaredType()->getCanonicalType());
+  auto lowered = getLoweredTypeInPrimaryContext(IGM, type);
   auto &ti = IGM.getTypeInfo(lowered);
   auto *typeLayoutEntry =
       ti.buildTypeLayoutEntry(IGM, lowered, /*useStructLayouts*/ true);
@@ -3131,8 +3130,7 @@ namespace {
       if (!IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnesses) ||
           !IGM.getOptions().EnableLayoutStringValueWitnesses)
         return nullptr;
-      auto lowered = getLoweredTypeInPrimaryContext(
-          IGM, Target->getDeclaredType()->getCanonicalType());
+      auto lowered = getLoweredTypeInPrimaryContext(IGM, Target);
       auto &ti = IGM.getTypeInfo(lowered);
       auto *typeLayoutEntry =
           ti.buildTypeLayoutEntry(IGM, lowered, /*useStructLayouts*/ true);
@@ -3792,8 +3790,7 @@ namespace {
       if (!IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnesses) ||
           !IGM.getOptions().EnableLayoutStringValueWitnesses)
         return nullptr;
-      auto lowered = getLoweredTypeInPrimaryContext(
-          IGM, Target->getDeclaredType()->getCanonicalType());
+      auto lowered = getLoweredTypeInPrimaryContext(IGM, Target);
       auto &ti = IGM.getTypeInfo(lowered);
       auto *typeLayoutEntry =
           ti.buildTypeLayoutEntry(IGM, lowered, /*useStructLayouts*/ true);
@@ -5042,8 +5039,7 @@ namespace {
       if (!IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnesses) ||
           !IGM.getOptions().EnableLayoutStringValueWitnesses)
         return nullptr;
-      auto lowered = getLoweredTypeInPrimaryContext(
-          IGM, Target->getDeclaredType()->getCanonicalType());
+      auto lowered = getLoweredTypeInPrimaryContext(IGM, Target);
       auto &ti = IGM.getTypeInfo(lowered);
       auto *typeLayoutEntry =
           ti.buildTypeLayoutEntry(IGM, lowered, /*useStructLayouts*/ true);
@@ -5136,10 +5132,8 @@ namespace {
   getValueWitnessTableForGenericValueType(IRGenModule &IGM,
                                           NominalTypeDecl *decl,
                                           bool &dependent) {
-    CanType unboundType
-      = decl->getDeclaredType()->getCanonicalType();
-    
-    dependent = hasDependentValueWitnessTable(IGM, unboundType);
+    dependent = hasDependentValueWitnessTable(IGM, decl);
+    CanType unboundType = decl->getDeclaredType()->getCanonicalType();
     return emitValueWitnessTable(IGM, unboundType, dependent,
                                  /*relative reference*/ true);
   }
@@ -5461,8 +5455,7 @@ namespace {
       if (!IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnesses) ||
           !IGM.getOptions().EnableLayoutStringValueWitnesses)
         return nullptr;
-      auto lowered = getLoweredTypeInPrimaryContext(
-          IGM, Target->getDeclaredType()->getCanonicalType());
+      auto lowered = getLoweredTypeInPrimaryContext(IGM, Target);
       auto &ti = IGM.getTypeInfo(lowered);
       auto *typeLayoutEntry =
           ti.buildTypeLayoutEntry(IGM, lowered, /*useStructLayouts*/ true);

lib/IRGen/GenReflection.cpp

@@ -1079,19 +1079,20 @@ void IRGenModule::emitBuiltinTypeMetadataRecord(CanType builtinType) {
 
 class MultiPayloadEnumDescriptorBuilder : public ReflectionMetadataBuilder {
   CanType type;
+  CanType typeInContext;
   const FixedTypeInfo *ti;
 
 public:
   MultiPayloadEnumDescriptorBuilder(IRGenModule &IGM,
                                     const NominalTypeDecl *nominalDecl)
     : ReflectionMetadataBuilder(IGM) {
     type = nominalDecl->getDeclaredType()->getCanonicalType();
-    ti = &cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(
-        nominalDecl->getDeclaredTypeInContext()->getCanonicalType()));
+    typeInContext = nominalDecl->getDeclaredTypeInContext()->getCanonicalType();
+    ti = &cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(typeInContext));
   }
 
   void layout() override {
-    auto &strategy = getEnumImplStrategy(IGM, getFormalTypeInPrimaryContext(type));
+    auto &strategy = getEnumImplStrategy(IGM, typeInContext);
     bool isMPE = strategy.getElementsWithPayload().size() > 1;
     assert(isMPE && "Cannot emit Multi-Payload Enum data for an enum that doesn't have multiple payloads");
 

lib/IRGen/GenValueWitness.cpp

@@ -386,54 +386,22 @@ static Address getArgAsBuffer(IRGenFunction &IGF,
                  getFixedBufferAlignment(IGF.IGM));
 }
 
-static CanType getFormalTypeInContext(CanType abstractType, DeclContext *dc) {
-  // Map the parent of any non-generic nominal type.
-  if (auto nominalType = dyn_cast<NominalType>(abstractType)) {
-    // If it doesn't have a parent, or the parent doesn't need remapping,
-    // do nothing.
-    auto abstractParentType = nominalType.getParent();
-    if (!abstractParentType) return abstractType;
-    auto parentType = getFormalTypeInContext(abstractParentType, dc);
-    if (abstractParentType == parentType) return abstractType;
-
-    // Otherwise, rebuild the type.
-    return CanType(NominalType::get(nominalType->getDecl(), parentType,
-                                    nominalType->getDecl()->getASTContext()));
-
-  // Map unbound types into their defining context.
-  } else if (auto ugt = dyn_cast<UnboundGenericType>(abstractType)) {
-    return dc->mapTypeIntoContext(ugt->getDecl()->getDeclaredInterfaceType())
-        ->getCanonicalType();
-
-  // Everything else stays the same.
-  } else {
-    return abstractType;
+/// Don't add new callers of this, it doesn't make any sense.
+static CanType getFormalTypeInPrimaryContext(CanType abstractType) {
+  auto *nominal = abstractType.getAnyNominal();
+  if (abstractType->isEqual(nominal->getDeclaredType())) {
+    return nominal->mapTypeIntoContext(nominal->getDeclaredInterfaceType())
+      ->getCanonicalType();
   }
-}
 
-/// Given an abstract type --- a type possibly expressed in terms of
-/// unbound generic types --- return the formal type within the type's
-/// primary defining context.
-CanType irgen::getFormalTypeInPrimaryContext(CanType abstractType) {
-  if (auto nominal = abstractType.getAnyNominal())
-    return getFormalTypeInContext(abstractType, nominal);
+  assert(!abstractType->hasUnboundGenericType());
   return abstractType;
 }
 
 SILType irgen::getLoweredTypeInPrimaryContext(IRGenModule &IGM,
-                                              CanType abstractType) {
-  if (auto boundGenericType = dyn_cast<BoundGenericType>(abstractType)) {
-    CanType concreteFormalType = getFormalTypeInPrimaryContext(abstractType);
-
-    auto concreteLoweredType = IGM.getLoweredType(concreteFormalType);
-    const auto *boundConcreteTI = &IGM.getTypeInfo(concreteLoweredType);
-    auto packing = boundConcreteTI->getFixedPacking(IGM);
-
-    abstractType =
-        boundGenericType->getDecl()->getDeclaredType()->getCanonicalType();
-  }
-  CanType concreteFormalType = getFormalTypeInPrimaryContext(abstractType);
-
+                                              NominalTypeDecl *type) {
+  CanType concreteFormalType = type->mapTypeIntoContext(
+      type->getDeclaredInterfaceType())->getCanonicalType();
   return IGM.getLoweredType(concreteFormalType);
 }
 
@@ -1191,8 +1159,9 @@ static void addValueWitnesses(IRGenModule &IGM, ConstantStructBuilder &B,
 /// True if a type has a generic-parameter-dependent value witness table.
 /// Currently, this is true if the size and/or alignment of the type is
 /// dependent on its generic parameters.
-bool irgen::hasDependentValueWitnessTable(IRGenModule &IGM, CanType ty) {
-  return !IGM.getTypeInfoForUnlowered(getFormalTypeInPrimaryContext(ty)).isFixedSize();
+bool irgen::hasDependentValueWitnessTable(IRGenModule &IGM, NominalTypeDecl *decl) {
+  auto ty = decl->mapTypeIntoContext(decl->getDeclaredInterfaceType());
+  return !IGM.getTypeInfoForUnlowered(ty).isFixedSize();
 }
 
 static void addValueWitnessesForAbstractType(IRGenModule &IGM,
@@ -1364,7 +1333,8 @@ ConstantReference irgen::emitValueWitnessTable(IRGenModule &IGM,
   // We should never be making a pattern if the layout isn't fixed.
   // The reverse can be true for types whose layout depends on
   // resilient types.
-  assert((!isPattern || hasDependentValueWitnessTable(IGM, abstractType)) &&
+  assert((!isPattern || hasDependentValueWitnessTable(
+              IGM, abstractType->getAnyNominal())) &&
          "emitting VWT pattern for fixed-layout type");
 
   ConstantInitBuilder builder(IGM);

lib/IRGen/GenValueWitness.h

@@ -36,7 +36,7 @@ namespace irgen {
   /// True if a type has a generic-parameter-dependent value witness table.
   /// Currently, this is true if the size and/or alignment of the type is
   /// dependent on its generic parameters.
-  bool hasDependentValueWitnessTable(IRGenModule &IGM, CanType ty);
+  bool hasDependentValueWitnessTable(IRGenModule &IGM, NominalTypeDecl *decl);
 
   /// Emit a value-witness table for the given type.
   ///
@@ -47,13 +47,8 @@ namespace irgen {
                                           bool isPattern,
                                           bool relativeReference);
 
-  /// Given an abstract type --- a type possibly expressed in terms of
-  /// unbound generic types --- return the formal type within the type's
-  /// primary defining context.
-  CanType getFormalTypeInPrimaryContext(CanType abstractType);
-
   SILType getLoweredTypeInPrimaryContext(IRGenModule &IGM,
-                                         CanType abstractType);
+                                         NominalTypeDecl *type);
 }
 }