AST: Move mapTypeOutOfContext() from GenericEnvironment to TypeBase

slavapestov · slavapestov · commit f07cde75e7b9 · 2017-11-15T22:52:13.000-08:00
It doesn't actually *use* the generic environment.
diff --git a/include/swift/AST/GenericEnvironment.h b/include/swift/AST/GenericEnvironment.h
@@ -37,6 +37,12 @@ class SILType;
 
 /// Describes the mapping between archetypes and interface types for the
 /// generic parameters of a DeclContext.
+///
+/// The most frequently used method here is mapTypeIntoContext(), which
+/// maps an interface type to a type written in terms of the generic
+/// environment's archetypes; to go in the other direction, use
+/// TypeBase::mapTypeOutOfContext().
+///
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
         : private llvm::TrailingObjects<GenericEnvironment, Type> {
   GenericSignature *Signature = nullptr;
@@ -126,13 +132,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   static Type mapTypeIntoContext(GenericEnvironment *genericEnv,
                                  Type type);
 
-  /// Map a contextual type to an interface type.
-  static Type mapTypeOutOfContext(GenericEnvironment *genericEnv,
-                                  Type type);
-
-  /// Map a contextual type to an interface type.
-  Type mapTypeOutOfContext(Type type) const;
-
   /// Map an interface type to a contextual type.
   Type mapTypeIntoContext(Type type) const;
 
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -524,6 +524,9 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// underlying type.
   Type eraseDynamicSelfType();
 
+  /// Map a contextual type to an interface type.
+  Type mapTypeOutOfContext();
+
   /// \brief Compute and return the set of type variables that occur within this
   /// type.
   ///
diff --git a/lib/AST/DeclContext.cpp b/lib/AST/DeclContext.cpp
@@ -306,8 +306,7 @@ Type DeclContext::mapTypeIntoContext(Type type) const {
 }
 
 Type DeclContext::mapTypeOutOfContext(Type type) const {
-  return GenericEnvironment::mapTypeOutOfContext(
-      getGenericEnvironmentOfContext(), type);
+  return type->mapTypeOutOfContext();
 }
 
 DeclContext *DeclContext::getLocalContext() {
diff --git a/lib/AST/GenericEnvironment.cpp b/lib/AST/GenericEnvironment.cpp
@@ -120,25 +120,13 @@ Type GenericEnvironment::mapTypeIntoContext(GenericEnvironment *env,
   return env->mapTypeIntoContext(type);
 }
 
-Type
-GenericEnvironment::mapTypeOutOfContext(GenericEnvironment *env,
-                                        Type type) {
-  assert(!type->hasTypeParameter() && "already have an interface type");
-
-  if (!env)
-    return type.substDependentTypesWithErrorTypes();
-
-  return env->mapTypeOutOfContext(type);
-}
-
-Type GenericEnvironment::mapTypeOutOfContext(Type type) const {
-  type = type.subst([&](SubstitutableType *t) -> Type {
-                      return cast<ArchetypeType>(t)->getInterfaceType();
-                    },
-                    MakeAbstractConformanceForGenericType(),
-                    SubstFlags::AllowLoweredTypes);
-  assert(!type->hasArchetype() && "not fully substituted");
-  return type;
+Type TypeBase::mapTypeOutOfContext() {
+  assert(!hasTypeParameter() && "already have an interface type");
+  return Type(this).subst([&](SubstitutableType *t) -> Type {
+      return cast<ArchetypeType>(t)->getInterfaceType();
+    },
+    MakeAbstractConformanceForGenericType(),
+    SubstFlags::AllowLoweredTypes);
 }
 
 Type GenericEnvironment::QueryInterfaceTypeSubstitutions::operator()(
diff --git a/lib/IRGen/GenHeap.cpp b/lib/IRGen/GenHeap.cpp
@@ -1530,7 +1530,7 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
     auto boxedInterfaceType = boxedType;
     if (env) {
       boxedInterfaceType = SILType::getPrimitiveType(
-        env->mapTypeOutOfContext(boxedType.getSwiftRValueType())
+        boxedType.getSwiftRValueType()->mapTypeOutOfContext()
            ->getCanonicalType(),
          boxedType.getCategory());
     }
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -1358,7 +1358,7 @@ ArchetypeType *TypeConverter::getExemplarArchetype(ArchetypeType *t) {
 
   // Map the archetype out of its own generic environment and into the
   // canonical generic environment.
-  auto interfaceType = genericEnv->mapTypeOutOfContext(t);
+  auto interfaceType = t->getInterfaceType();
   auto exemplar = canGenericEnv->mapTypeIntoContext(interfaceType)
                     ->castTo<ArchetypeType>();
   assert(isExemplarArchetype(exemplar));
diff --git a/lib/ParseSIL/ParseSIL.cpp b/lib/ParseSIL/ParseSIL.cpp
@@ -842,7 +842,7 @@ void SILParser::convertRequirements(SILFunction *F,
     Ty.getTypeRepr()->walk(PerformLookup);
     performTypeLocChecking(Ty, /* IsSIL */ false);
     assert(Ty.getType());
-    return GenericEnv->mapTypeOutOfContext(Ty.getType()->getCanonicalType());
+    return Ty.getType()->mapTypeOutOfContext();
   };
 
   for (auto &Req : From) {
@@ -1049,9 +1049,12 @@ bool SILParser::parseASTType(CanType &result, GenericEnvironment *env) {
   TypeLoc loc = parsedType.get();
   if (performTypeLocChecking(loc, /*IsSILType=*/ false, env))
     return true;
-  result = loc.getType()->getCanonicalType();
+
   if (env)
-    result = env->mapTypeOutOfContext(result)->getCanonicalType();
+    result = loc.getType()->mapTypeOutOfContext()->getCanonicalType();
+  else
+    result = loc.getType()->getCanonicalType();
+
   // Invoke the callback on the parsed type.
   ParsedTypeCallback(loc.getType());
   return false;
@@ -2615,8 +2618,7 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
                 
                 if (patternEnv)
                   loweredTy = SILType::getPrimitiveType(
-                    patternEnv
-                      ->mapTypeOutOfContext(loweredTy.getSwiftRValueType())
+                    loweredTy.getSwiftRValueType()->mapTypeOutOfContext()
                       ->getCanonicalType(),
                     loweredTy.getCategory());
 
diff --git a/lib/SIL/SILFunction.cpp b/lib/SIL/SILFunction.cpp
@@ -205,8 +205,7 @@ SILType GenericEnvironment::mapTypeIntoContext(SILModule &M,
 }
 
 Type SILFunction::mapTypeOutOfContext(Type type) const {
-  return GenericEnvironment::mapTypeOutOfContext(
-      getGenericEnvironment(), type);
+  return type->mapTypeOutOfContext();
 }
 
 bool SILFunction::isNoReturnFunction() const {
diff --git a/lib/SIL/SILFunctionType.cpp b/lib/SIL/SILFunctionType.cpp
@@ -881,9 +881,8 @@ static CanSILFunctionType getSILFunctionType(
     for (auto capture : loweredCaptures.getCaptures()) {
       if (capture.isDynamicSelfMetadata()) {
         ParameterConvention convention = ParameterConvention::Direct_Unowned;
-        auto dynamicSelfInterfaceType = GenericEnvironment::mapTypeOutOfContext(
-          function->getGenericEnvironment(),
-          loweredCaptures.getDynamicSelfType());
+        auto dynamicSelfInterfaceType =
+            loweredCaptures.getDynamicSelfType()->mapTypeOutOfContext();
         
         auto selfMetatype = MetatypeType::get(
             dynamicSelfInterfaceType,
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
@@ -2502,7 +2502,7 @@ TypeConverter::getContextBoxTypeForCapture(ValueDecl *captured,
     auto homeSig = captured->getDeclContext()
         ->getGenericSignatureOfContext();
     loweredInterfaceType =
-      env->mapTypeOutOfContext(loweredInterfaceType)
+      loweredInterfaceType->mapTypeOutOfContext()
         ->getCanonicalType(homeSig);
   }
   
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -3059,7 +3059,7 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenFunction &SGF,
   SmallVector<CanType, 2> interfaceSubs;
   for (auto &sub : subs) {
     interfaceSubs.push_back(
-      GenericEnvironment::mapTypeOutOfContext(genericEnv, sub.getReplacement())
+      sub.getReplacement()->mapTypeOutOfContext()
       ->getCanonicalType());
   }
   auto name = Mangle::ASTMangler()
@@ -3182,7 +3182,7 @@ SILFunction *getOrCreateKeyPathSetter(SILGenFunction &SGF,
   SmallVector<CanType, 2> interfaceSubs;
   for (auto &sub : subs) {
     interfaceSubs.push_back(
-      GenericEnvironment::mapTypeOutOfContext(genericEnv, sub.getReplacement())
+      sub.getReplacement()->mapTypeOutOfContext()
       ->getCanonicalType());
   }
   auto name = Mangle::ASTMangler().mangleKeyPathSetterThunkHelper(property,
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -2836,26 +2836,23 @@ CanSILFunctionType SILGenFunction::buildThunkType(
   SmallVector<SILParameterInfo, 4> interfaceParams;
   interfaceParams.reserve(params.size());
   for (auto &param : params) {
-    auto paramIfaceTy = GenericEnvironment::mapTypeOutOfContext(
-        genericEnv, param.getType());
+    auto paramIfaceTy = param.getType()->mapTypeOutOfContext();
     interfaceParams.push_back(
       SILParameterInfo(paramIfaceTy->getCanonicalType(genericSig),
                        param.getConvention()));
   }
 
   SmallVector<SILYieldInfo, 4> interfaceYields;
   for (auto &yield : expectedType->getYields()) {
-    auto yieldIfaceTy = GenericEnvironment::mapTypeOutOfContext(
-        genericEnv, yield.getType());
+    auto yieldIfaceTy = yield.getType()->mapTypeOutOfContext();
     auto interfaceYield =
       yield.getWithType(yieldIfaceTy->getCanonicalType(genericSig));
     interfaceYields.push_back(interfaceYield);
   }
 
   SmallVector<SILResultInfo, 4> interfaceResults;
   for (auto &result : expectedType->getResults()) {
-    auto resultIfaceTy = GenericEnvironment::mapTypeOutOfContext(
-        genericEnv, result.getType());
+    auto resultIfaceTy = result.getType()->mapTypeOutOfContext();
     auto interfaceResult =
       result.getWithType(resultIfaceTy->getCanonicalType(genericSig));
     interfaceResults.push_back(interfaceResult);
@@ -2864,8 +2861,7 @@ CanSILFunctionType SILGenFunction::buildThunkType(
   Optional<SILResultInfo> interfaceErrorResult;
   if (expectedType->hasErrorResult()) {
     auto errorResult = expectedType->getErrorResult();
-    auto errorIfaceTy = GenericEnvironment::mapTypeOutOfContext(
-        genericEnv, errorResult.getType());
+    auto errorIfaceTy = errorResult.getType()->mapTypeOutOfContext();
     interfaceErrorResult = SILResultInfo(
         errorIfaceTy->getCanonicalType(genericSig),
         expectedType->getErrorResult().getConvention());
diff --git a/lib/SILGen/SILGenThunk.cpp b/lib/SILGen/SILGenThunk.cpp
@@ -370,12 +370,10 @@ getOrCreateReabstractionThunk(GenericEnvironment *genericEnv,
 
   // Mangle the reabstraction thunk.
   // Substitute context parameters out of the "from" and "to" types.
-  auto fromInterfaceType
-      = GenericEnvironment::mapTypeOutOfContext(genericEnv, fromType)
-              ->getCanonicalType();
-  auto toInterfaceType
-      = GenericEnvironment::mapTypeOutOfContext(genericEnv, toType)
-              ->getCanonicalType();
+  auto fromInterfaceType = fromType->mapTypeOutOfContext()
+    ->getCanonicalType();
+  auto toInterfaceType = toType->mapTypeOutOfContext()
+    ->getCanonicalType();
 
   Mangle::ASTMangler NewMangler;
   std::string name = NewMangler.mangleReabstractionThunkHelper(thunkType,
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -1394,10 +1394,7 @@ void FunctionSignaturePartialSpecializer::
 
     // Add a same type requirement based on the provided generic parameter
     // substitutions.
-    auto ReplacementCallerInterfaceTy = Replacement;
-    if (CallerGenericEnv)
-      ReplacementCallerInterfaceTy =
-          CallerGenericEnv->mapTypeOutOfContext(Replacement);
+    auto ReplacementCallerInterfaceTy = Replacement->mapTypeOutOfContext();
 
     auto SpecializedReplacementCallerInterfaceTy =
         ReplacementCallerInterfaceTy.subst(
@@ -1537,8 +1534,8 @@ void FunctionSignaturePartialSpecializer::computeCallerInterfaceSubs(
         // First, map callee's interface type to specialized interface type.
         auto Ty = Type(type).subst(CalleeInterfaceToSpecializedInterfaceMap);
         Type SpecializedInterfaceTy =
-            SpecializedGenericEnv->mapTypeOutOfContext(
-                SpecializedGenericEnv->mapTypeIntoContext(Ty));
+          SpecializedGenericEnv->mapTypeIntoContext(Ty)
+            ->mapTypeOutOfContext();
         assert(!SpecializedInterfaceTy->hasError());
         return SpecializedInterfaceTy;
       },
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -1669,7 +1669,6 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
   DeclContext *DC = D->getDeclContext();
   auto *FD = cast<AbstractFunctionDecl>(D);
   auto *genericSig = FD->getGenericSignature();
-  auto *genericEnv = FD->getGenericEnvironment();
   auto *trailingWhereClause = attr->getTrailingWhereClause();
 
   if (!trailingWhereClause) {
@@ -1721,9 +1720,9 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
 
       // Map types to their interface types.
       if (firstType)
-        interfaceFirstType = genericEnv->mapTypeOutOfContext(firstType);
+        interfaceFirstType = firstType->mapTypeOutOfContext();
       if (secondType)
-        interfaceSecondType = genericEnv->mapTypeOutOfContext(secondType);
+        interfaceSecondType = secondType->mapTypeOutOfContext();
 
       collectUsedGenericParameters(interfaceFirstType,
                                    constrainedGenericParams);
@@ -1770,7 +1769,7 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
 
       // Map types to their interface types.
       if (subjectType)
-        interfaceSubjectType = genericEnv->mapTypeOutOfContext(subjectType);
+        interfaceSubjectType = subjectType->mapTypeOutOfContext();
 
       collectUsedGenericParameters(interfaceSubjectType,
                                    constrainedGenericParams);
@@ -1809,7 +1808,7 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
 
       // Map types to their interface types.
       if (subjectType)
-        interfaceSubjectType = genericEnv->mapTypeOutOfContext(subjectType);
+        interfaceSubjectType = subjectType->mapTypeOutOfContext();
 
       collectUsedGenericParameters(interfaceSubjectType,
                                    constrainedGenericParams);
@@ -1820,8 +1819,7 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
         continue;
 
 
-      auto interfaceLayoutConstraint =
-          genericEnv->mapTypeOutOfContext(constraint);
+      auto interfaceLayoutConstraint = constraint->mapTypeOutOfContext();
 
       // Re-create a requirement using the resolved interface types.
       auto resolvedReq = RequirementRepr::getTypeConstraint(
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -79,8 +79,7 @@ void GenericTypeToArchetypeResolver::recordParamType(ParamDecl *decl, Type type)
   // When type checking functions, the CompleteGenericTypeResolver sets
   // the interface type.
   if (!decl->hasInterfaceType())
-    decl->setInterfaceType(GenericEnvironment::mapTypeOutOfContext(
-        GenericEnv, type));
+    decl->setInterfaceType(type->mapTypeOutOfContext());
 }
 
 Type ProtocolRequirementTypeResolver::mapTypeIntoContext(Type type) {
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -2346,8 +2346,8 @@ Type TypeResolver::resolveASTFunctionType(FunctionTypeRepr *repr,
 
   // SIL uses polymorphic function types to resolve overloaded member functions.
   if (auto genericEnv = repr->getGenericEnvironment()) {
-    inputTy = genericEnv->mapTypeOutOfContext(inputTy);
-    outputTy = genericEnv->mapTypeOutOfContext(outputTy);
+    inputTy = inputTy->mapTypeOutOfContext();
+    outputTy = outputTy->mapTypeOutOfContext();
     return GenericFunctionType::get(genericEnv->getGenericSignature(),
                                     inputTy, outputTy, extInfo);
   }
@@ -2406,7 +2406,7 @@ Type TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
     genericSig = genericEnv->getGenericSignature()->getCanonicalSignature();
     
     for (auto &field : fields) {
-      auto transTy = genericEnv->mapTypeOutOfContext(field.getLoweredType());
+      auto transTy = field.getLoweredType()->mapTypeOutOfContext();
       field = {transTy->getCanonicalType(), field.isMutable()};
     }
   }
@@ -2547,24 +2547,24 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
     genericSig = genericEnv->getGenericSignature()->getCanonicalSignature();
  
     for (auto &param : params) {
-      auto transParamType = genericEnv->mapTypeOutOfContext(
-          param.getType())->getCanonicalType();
+      auto transParamType = param.getType()->mapTypeOutOfContext()
+          ->getCanonicalType();
       interfaceParams.push_back(param.getWithType(transParamType));
     }
     for (auto &yield : yields) {
-      auto transYieldType = genericEnv->mapTypeOutOfContext(
-          yield.getType())->getCanonicalType();
+      auto transYieldType = yield.getType()->mapTypeOutOfContext()
+          ->getCanonicalType();
       interfaceYields.push_back(yield.getWithType(transYieldType));
     }
     for (auto &result : results) {
-      auto transResultType = genericEnv->mapTypeOutOfContext(
-          result.getType())->getCanonicalType();
+      auto transResultType = result.getType()->mapTypeOutOfContext()
+          ->getCanonicalType();
       interfaceResults.push_back(result.getWithType(transResultType));
     }
 
     if (errorResult) {
-      auto transErrorResultType = genericEnv->mapTypeOutOfContext(
-          errorResult->getType())->getCanonicalType();
+      auto transErrorResultType = errorResult->getType()->mapTypeOutOfContext()
+          ->getCanonicalType();
       interfaceErrorResult =
         errorResult->getWithType(transErrorResultType);
     }
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp

Original file line number	Diff line number	Diff line change
`@@ -306,8 +306,7 @@ Type DeclContext::mapTypeIntoContext(Type type) const {`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`Type DeclContext::mapTypeOutOfContext(Type type) const {`
`309`		`- return GenericEnvironment::mapTypeOutOfContext(`
`310`		`- getGenericEnvironmentOfContext(), type);`
	`309`	`+ return type->mapTypeOutOfContext();`
`311`	`310`	`}`
`312`	`311`
`313`	`312`	`DeclContext *DeclContext::getLocalContext() {`
Original file line number	Diff line number	Diff line change
`@@ -1530,7 +1530,7 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {`
`1530`	`1530`	`auto boxedInterfaceType = boxedType;`
`1531`	`1531`	`if (env) {`
`1532`	`1532`	`boxedInterfaceType = SILType::getPrimitiveType(`
`1533`		`- env->mapTypeOutOfContext(boxedType.getSwiftRValueType())`
	`1533`	`+ boxedType.getSwiftRValueType()->mapTypeOutOfContext()`
`1534`	`1534`	`->getCanonicalType(),`
`1535`	`1535`	`boxedType.getCategory());`
`1536`	`1536`	`}`
Original file line number	Diff line number	Diff line change
`@@ -205,8 +205,7 @@ SILType GenericEnvironment::mapTypeIntoContext(SILModule &M,`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`Type SILFunction::mapTypeOutOfContext(Type type) const {`
`208`		`- return GenericEnvironment::mapTypeOutOfContext(`
`209`		`- getGenericEnvironment(), type);`
	`208`	`+ return type->mapTypeOutOfContext();`
`210`	`209`	`}`
`211`	`210`
`212`	`211`	`bool SILFunction::isNoReturnFunction() const {`
Original file line number	Diff line number	Diff line change
`@@ -2502,7 +2502,7 @@ TypeConverter::getContextBoxTypeForCapture(ValueDecl *captured,`
`2502`	`2502`	`auto homeSig = captured->getDeclContext()`
`2503`	`2503`	`->getGenericSignatureOfContext();`
`2504`	`2504`	`loweredInterfaceType =`
`2505`		`- env->mapTypeOutOfContext(loweredInterfaceType)`
	`2505`	`+ loweredInterfaceType->mapTypeOutOfContext()`
`2506`	`2506`	`->getCanonicalType(homeSig);`
`2507`	`2507`	`}`
`2508`	`2508`