Skip to content

Commit 6e764aa

Browse files
AnthonyLatsisAnthonyLatsis
committed
TypeResolution: Remove the last remaining use of 'forContextual'
1 parent c55f54d commit 6e764aa

File tree

6 files changed

+70
-58
lines changed

6 files changed

+70
-58
lines changed

‎include/swift/Subsystems.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -157,7 +157,7 @@ namespace swift {
157157
/// emitted.
158158
void performWholeModuleTypeChecking(SourceFile &SF);
159159

160-
/// Resolve the given \c TypeRepr to a contextual type.
160+
/// Resolve the given \c TypeRepr to an interface type.
161161
///
162162
/// This is used when dealing with partial source files (e.g. SIL parsing,
163163
/// code completion).

‎lib/IDE/CodeCompletion.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1580,11 +1580,13 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
15801580
/*GenericParams=*/nullptr,
15811581
CurDeclContext,
15821582
/*ProduceDiagnostics=*/false);
1583-
ParsedTypeLoc.setType(ty);
1584-
if (!ParsedTypeLoc.isError()) {
1583+
if (!ty->hasError()) {
1584+
ParsedTypeLoc.setType(CurDeclContext->mapTypeIntoContext(ty));
15851585
return true;
15861586
}
15871587

1588+
ParsedTypeLoc.setType(ty);
1589+
15881590
// It doesn't type check as a type, so see if it's a qualifying module name.
15891591
if (auto *ITR = dyn_cast<IdentTypeRepr>(ParsedTypeLoc.getTypeRepr())) {
15901592
const auto &componentRange = ITR->getComponentRange();

‎lib/IDE/ExprContextAnalysis.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -308,7 +308,7 @@ void swift::ide::collectPossibleReturnTypesFromContext(
308308
const_cast<DeclContext *>(DC), /*diagnostics=*/false);
309309

310310
if (!type->hasError()) {
311-
candidates.push_back(type);
311+
candidates.push_back(DC->mapTypeIntoContext(type));
312312
return;
313313
}
314314
}

‎lib/SIL/Parser/ParseSIL.cpp

Lines changed: 43 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -150,7 +150,7 @@ namespace {
150150

151151
Type performTypeResolution(TypeRepr *TyR, bool IsSILType,
152152
GenericEnvironment *GenericEnv,
153-
GenericParamList *GenericParams);
153+
GenericParamList *GenericParams) const;
154154

155155
void convertRequirements(ArrayRef<RequirementRepr> From,
156156
SmallVectorImpl<Requirement> &To);
@@ -915,9 +915,8 @@ void SILParser::convertRequirements(ArrayRef<RequirementRepr> From,
915915
// Use parser lexical scopes to resolve references
916916
// to the generic parameters.
917917
auto ResolveToInterfaceType = [&](TypeRepr *TyR) -> Type {
918-
return performTypeResolution(TyR, /*IsSILType=*/false,
919-
ContextGenericEnv, ContextGenericParams)
920-
->mapTypeOutOfContext();
918+
return performTypeResolution(TyR, /*IsSILType=*/false, ContextGenericEnv,
919+
ContextGenericParams);
921920
};
922921

923922
for (auto &Req : From) {
@@ -1187,7 +1186,7 @@ static bool parseDeclSILOptional(bool *isTransparent,
11871186

11881187
Type SILParser::performTypeResolution(TypeRepr *TyR, bool IsSILType,
11891188
GenericEnvironment *GenericEnv,
1190-
GenericParamList *GenericParams) {
1189+
GenericParamList *GenericParams) const {
11911190
if (GenericEnv == nullptr)
11921191
GenericEnv = ContextGenericEnv;
11931192

@@ -1251,26 +1250,26 @@ bool SILParser::parseASTType(CanType &result,
12511250
ParserResult<TypeRepr> parsedType = P.parseType();
12521251
if (parsedType.isNull()) return true;
12531252

1254-
bool wantInterfaceType = true;
1253+
bool wantContextualType = false;
12551254
if (genericEnv == nullptr) {
12561255
genericEnv = ContextGenericEnv;
1257-
wantInterfaceType = false;
1256+
wantContextualType = true;
12581257
}
12591258
if (genericParams == nullptr)
12601259
genericParams = ContextGenericParams;
12611260

12621261
bindSILGenericParams(parsedType.get());
12631262

1264-
const auto resolvedType =
1265-
performTypeResolution(parsedType.get(), /*isSILType=*/false,
1266-
genericEnv, genericParams);
1263+
auto resolvedType = performTypeResolution(
1264+
parsedType.get(), /*isSILType=*/false, genericEnv, genericParams);
1265+
if (wantContextualType && genericEnv) {
1266+
resolvedType = genericEnv->mapTypeIntoContext(resolvedType);
1267+
}
1268+
12671269
if (resolvedType->hasError())
12681270
return true;
12691271

1270-
if (wantInterfaceType)
1271-
result = resolvedType->mapTypeOutOfContext()->getCanonicalType();
1272-
else
1273-
result = resolvedType->getCanonicalType();
1272+
result = resolvedType->getCanonicalType();
12741273

12751274
return false;
12761275
}
@@ -1363,9 +1362,12 @@ bool SILParser::parseSILType(SILType &Result,
13631362
auto *attrRepr =
13641363
P.applyAttributeToType(
13651364
TyR.get(), attrs, specifier, specifierLoc, isolatedLoc);
1366-
const auto Ty =
1367-
performTypeResolution(attrRepr, /*IsSILType=*/true,
1368-
OuterGenericEnv, OuterGenericParams);
1365+
auto Ty = performTypeResolution(attrRepr, /*IsSILType=*/true, OuterGenericEnv,
1366+
OuterGenericParams);
1367+
if (OuterGenericEnv) {
1368+
Ty = OuterGenericEnv->mapTypeIntoContext(Ty);
1369+
}
1370+
13691371
if (Ty->hasError())
13701372
return true;
13711373

@@ -1930,9 +1932,12 @@ bool SILParser::parseSubstitutions(SmallVectorImpl<ParsedSubstitution> &parsed,
19301932
if (TyR.isNull())
19311933
return true;
19321934

1933-
const auto Ty =
1934-
performTypeResolution(TyR.get(), /*IsSILType=*/false,
1935-
GenericEnv, GenericParams);
1935+
auto Ty = performTypeResolution(TyR.get(), /*IsSILType=*/false, GenericEnv,
1936+
GenericParams);
1937+
if (GenericEnv) {
1938+
Ty = GenericEnv->mapTypeIntoContext(Ty);
1939+
}
1940+
19361941
if (Ty->hasError())
19371942
return true;
19381943
parsed.push_back({Loc, Ty});
@@ -2321,9 +2326,8 @@ bool SILParser::parseSILDeclRef(SILDeclRef &Member, bool FnTypeRequired) {
23212326
genericParams = fnType->getGenericParams();
23222327
}
23232328

2324-
const auto Ty =
2325-
performTypeResolution(TyR.get(), /*IsSILType=*/false,
2326-
genericEnv, genericParams);
2329+
const auto Ty = performTypeResolution(TyR.get(), /*IsSILType=*/false,
2330+
genericEnv, genericParams);
23272331
if (Ty->hasError())
23282332
return true;
23292333

@@ -6841,9 +6845,12 @@ ProtocolConformanceRef SILParser::parseProtocolConformanceHelper(
68416845
if (witnessParams == nullptr)
68426846
witnessParams = ContextGenericParams;
68436847

6844-
const auto ConformingTy =
6845-
performTypeResolution(TyR.get(), /*IsSILType=*/false,
6846-
witnessEnv, witnessParams);
6848+
auto ConformingTy = performTypeResolution(TyR.get(), /*IsSILType=*/false,
6849+
witnessEnv, witnessParams);
6850+
if (witnessEnv) {
6851+
ConformingTy = witnessEnv->mapTypeIntoContext(ConformingTy);
6852+
}
6853+
68476854
if (ConformingTy->hasError())
68486855
return ProtocolConformanceRef();
68496856

@@ -6957,13 +6964,17 @@ static bool parseSILWitnessTableEntry(
69576964
if (TyR.isNull())
69586965
return true;
69596966

6960-
const auto Ty =
6967+
auto Ty =
69616968
swift::performTypeResolution(TyR.get(), P.Context,
69626969
/*isSILMode=*/false,
69636970
/*isSILType=*/false,
69646971
witnessEnv,
69656972
witnessParams,
69666973
&P.SF);
6974+
if (witnessEnv) {
6975+
Ty = witnessEnv->mapTypeIntoContext(Ty);
6976+
}
6977+
69676978
if (Ty->hasError())
69686979
return true;
69696980

@@ -7018,12 +7029,16 @@ static bool parseSILWitnessTableEntry(
70187029
if (TyR.isNull())
70197030
return true;
70207031

7021-
const auto Ty =
7032+
auto Ty =
70227033
swift::performTypeResolution(TyR.get(), P.Context,
70237034
/*isSILMode=*/false,
70247035
/*isSILType=*/false,
70257036
witnessEnv, witnessParams,
70267037
&P.SF);
7038+
if (witnessEnv) {
7039+
Ty = witnessEnv->mapTypeIntoContext(Ty);
7040+
}
7041+
70277042
if (Ty->hasError())
70287043
return true;
70297044

‎lib/Sema/TypeCheckType.cpp

Lines changed: 10 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1854,9 +1854,10 @@ namespace {
18541854
DifferentiabilityKind diffKind =
18551855
DifferentiabilityKind::NonDifferentiable,
18561856
Type globalActor = Type());
1857-
SmallVector<AnyFunctionType::Param, 8> resolveASTFunctionTypeParams(
1858-
TupleTypeRepr *inputRepr, TypeResolutionOptions options,
1859-
bool requiresMappingOut, DifferentiabilityKind diffKind);
1857+
SmallVector<AnyFunctionType::Param, 8>
1858+
resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
1859+
TypeResolutionOptions options,
1860+
DifferentiabilityKind diffKind);
18601861

18611862
NeverNullType resolveSILFunctionType(
18621863
FunctionTypeRepr *repr, TypeResolutionOptions options,
@@ -2650,7 +2651,10 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
26502651
if (SF->Kind == SourceFileKind::SIL) {
26512652
if (((attrs.has(TAK_sil_weak) || attrs.has(TAK_sil_unmanaged)) &&
26522653
ty->getOptionalObjectType()) ||
2653-
(!attrs.has(TAK_sil_weak) && ty->hasReferenceSemantics())) {
2654+
(!attrs.has(TAK_sil_weak) &&
2655+
GenericEnvironment::mapTypeIntoContext(
2656+
resolution.getGenericSignature().getGenericEnvironment(), ty)
2657+
->hasReferenceSemantics())) {
26542658
ty = ReferenceStorageType::get(ty, attrs.getOwnership(),
26552659
getASTContext());
26562660
attrs.clearOwnership();
@@ -2710,7 +2714,6 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
27102714
SmallVector<AnyFunctionType::Param, 8>
27112715
TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
27122716
TypeResolutionOptions options,
2713-
bool requiresMappingOut,
27142717
DifferentiabilityKind diffKind) {
27152718
SmallVector<AnyFunctionType::Param, 8> elements;
27162719
elements.reserve(inputRepr->getNumElements());
@@ -2738,11 +2741,6 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
27382741
continue;
27392742
}
27402743

2741-
// Parameters of polymorphic functions speak in terms of interface types.
2742-
if (requiresMappingOut) {
2743-
ty = ty->mapTypeOutOfContext();
2744-
}
2745-
27462744
bool autoclosure = false;
27472745
if (auto *ATR = dyn_cast<AttributedTypeRepr>(eltTypeRepr))
27482746
autoclosure = ATR->getAttrs().has(TAK_autoclosure);
@@ -2878,9 +2876,8 @@ NeverNullType TypeResolver::resolveASTFunctionType(
28782876

28792877
TypeResolutionOptions options = None;
28802878
options |= parentOptions.withoutContext().getFlags();
2881-
auto params = resolveASTFunctionTypeParams(
2882-
repr->getArgsTypeRepr(), options,
2883-
repr->getGenericEnvironment() != nullptr, diffKind);
2879+
auto params =
2880+
resolveASTFunctionTypeParams(repr->getArgsTypeRepr(), options, diffKind);
28842881

28852882
auto resultOptions = options.withoutContext();
28862883
resultOptions.setContext(TypeResolverContext::FunctionResult);
@@ -2926,7 +2923,6 @@ NeverNullType TypeResolver::resolveASTFunctionType(
29262923

29272924
// SIL uses polymorphic function types to resolve overloaded member functions.
29282925
if (auto genericEnv = repr->getGenericEnvironment()) {
2929-
outputTy = outputTy->mapTypeOutOfContext();
29302926
return GenericFunctionType::get(genericEnv->getGenericSignature(),
29312927
params, outputTy, extInfo);
29322928
}

‎lib/Sema/TypeChecker.cpp

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -369,22 +369,21 @@ Type swift::performTypeResolution(TypeRepr *TyR, ASTContext &Ctx,
369369
if (isSILType)
370370
options |= TypeResolutionFlags::SILType;
371371

372-
const auto resolution = TypeResolution::forContextual(
373-
DC, GenericEnv, options,
374-
[](auto unboundTy) {
375-
// FIXME: Don't let unbound generic types escape type resolution.
376-
// For now, just return the unbound generic type.
377-
return unboundTy;
378-
},
379-
// FIXME: Don't let placeholder types escape type resolution.
380-
// For now, just return the placeholder type.
381-
PlaceholderType::get);
382-
383372
Optional<DiagnosticSuppression> suppression;
384373
if (!ProduceDiagnostics)
385374
suppression.emplace(Ctx.Diags);
386375

387-
return resolution.resolveType(TyR, GenericParams);
376+
return TypeResolution::forInterface(
377+
DC, GenericEnv, options,
378+
[](auto unboundTy) {
379+
// FIXME: Don't let unbound generic types escape type resolution.
380+
// For now, just return the unbound generic type.
381+
return unboundTy;
382+
},
383+
// FIXME: Don't let placeholder types escape type resolution.
384+
// For now, just return the placeholder type.
385+
PlaceholderType::get)
386+
.resolveType(TyR, GenericParams);
388387
}
389388

390389
namespace {

0 commit comments

Comments
 (0)