Skip to content

Commit 4c1e6ac

Browse files
swift-ciswift-ci
authored
Merge pull request #3340 from slavapestov/function-interface-type-cleanup
2 parents 1e2d192 + 5a90293 commit 4c1e6ac

File tree

16 files changed

+117
-130
lines changed

16 files changed

+117
-130
lines changed

‎include/swift/AST/Decl.h

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5508,9 +5508,6 @@ class ConstructorDecl : public AbstractFunctionDecl {
55085508

55095509
ParameterList *ParameterLists[2];
55105510

5511-
/// The type of the initializing constructor.
5512-
Type InitializerType;
5513-
55145511
/// The interface type of the initializing constructor.
55155512
Type InitializerInterfaceType;
55165513

@@ -5542,10 +5539,6 @@ class ConstructorDecl : public AbstractFunctionDecl {
55425539
/// \brief Get the type of the constructed object.
55435540
Type getResultType() const;
55445541

5545-
/// Get the type of the initializing constructor.
5546-
Type getInitializerType() const { return InitializerType; }
5547-
void setInitializerType(Type t) { InitializerType = t; }
5548-
55495542
/// Get the interface type of the initializing constructor.
55505543
Type getInitializerInterfaceType();
55515544
void setInitializerInterfaceType(Type t);

‎lib/AST/ASTContext.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -902,7 +902,8 @@ static CanType stripImmediateLabels(CanType type) {
902902
/// Check whether the given function is non-generic.
903903
static bool isNonGenericIntrinsic(FuncDecl *fn, CanType &input,
904904
CanType &output) {
905-
auto fnType = dyn_cast<FunctionType>(fn->getType()->getCanonicalType());
905+
auto fnType = dyn_cast<FunctionType>(fn->getInterfaceType()
906+
->getCanonicalType());
906907
if (!fnType)
907908
return false;
908909

‎lib/AST/Builtins.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -168,6 +168,7 @@ getBuiltinFunction(Identifier Id, ArrayRef<Type> argTypes, Type ResType,
168168
/*GenericParams=*/nullptr,
169169
paramList, FnType,
170170
TypeLoc::withoutLoc(ResType), DC);
171+
FD->setInterfaceType(FnType);
171172
FD->setImplicit();
172173
FD->setAccessibility(Accessibility::Public);
173174
return FD;

‎lib/AST/Decl.cpp

Lines changed: 3 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1705,6 +1705,9 @@ Type ValueDecl::getInterfaceType() const {
17051705
if (!hasType())
17061706
return Type();
17071707

1708+
assert(!isa<AbstractFunctionDecl>(this) &&
1709+
"functions should have an interface type");
1710+
17081711
// If the type involves a type variable, don't cache it.
17091712
auto type = getType();
17101713
assert((type.isNull() || !type->is<PolymorphicFunctionType>())
@@ -4550,17 +4553,6 @@ Type ConstructorDecl::getResultType() const {
45504553
}
45514554

45524555
Type ConstructorDecl::getInitializerInterfaceType() {
4553-
if (!InitializerInterfaceType) {
4554-
assert((!InitializerType || !InitializerType->is<PolymorphicFunctionType>())
4555-
&& "polymorphic function type is invalid interface type");
4556-
4557-
// Don't cache type variable types.
4558-
if (InitializerType->hasTypeVariable())
4559-
return InitializerType;
4560-
4561-
InitializerInterfaceType = InitializerType;
4562-
}
4563-
45644556
return InitializerInterfaceType;
45654557
}
45664558

‎lib/ClangImporter/ImportDecl.cpp

Lines changed: 72 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -373,7 +373,8 @@ makeEnumRawValueConstructor(ClangImporter::Implementation &Impl,
373373
auto allocFnTy = FunctionType::get(metaTy, fnTy);
374374
auto initFnTy = FunctionType::get(enumTy, fnTy);
375375
ctorDecl->setType(allocFnTy);
376-
ctorDecl->setInitializerType(initFnTy);
376+
ctorDecl->setInterfaceType(allocFnTy);
377+
ctorDecl->setInitializerInterfaceType(initFnTy);
377378

378379
// Don't bother synthesizing the body if we've already finished type-checking.
379380
if (Impl.hasFinishedTypeChecking())
@@ -428,8 +429,13 @@ static FuncDecl *makeEnumRawValueGetter(ClangImporter::Implementation &Impl,
428429
/*GenericParams=*/nullptr, params, Type(),
429430
TypeLoc::withoutLoc(enumDecl->getRawType()), enumDecl);
430431
getterDecl->setImplicit();
431-
getterDecl->setType(ParameterList::getFullInterfaceType(enumDecl->getRawType(),
432-
params, enumDecl));
432+
433+
auto type = ParameterList::getFullInterfaceType(enumDecl->getRawType(),
434+
params, enumDecl);
435+
436+
getterDecl->setType(type);
437+
getterDecl->setInterfaceType(type);
438+
433439
getterDecl->setBodyResultType(enumDecl->getRawType());
434440
getterDecl->setAccessibility(Accessibility::Public);
435441

@@ -488,8 +494,13 @@ static FuncDecl *makeNewtypeBridgedRawValueGetter(
488494
params, Type(),
489495
TypeLoc::withoutLoc(computedType), structDecl);
490496
getterDecl->setImplicit();
491-
getterDecl->setType(ParameterList::getFullInterfaceType(computedType, params,
492-
structDecl));
497+
498+
auto type = ParameterList::getFullInterfaceType(computedType, params,
499+
structDecl);
500+
501+
getterDecl->setType(type);
502+
getterDecl->setInterfaceType(type);
503+
493504
getterDecl->setBodyResultType(computedType);
494505
getterDecl->setAccessibility(Accessibility::Public);
495506

@@ -535,8 +546,12 @@ static FuncDecl *makeFieldGetterDecl(ClangImporter::Implementation &Impl,
535546
/*GenericParams=*/nullptr, params, Type(),
536547
TypeLoc::withoutLoc(getterType), importedDecl, clangNode);
537548
getterDecl->setAccessibility(Accessibility::Public);
538-
getterDecl->setType(ParameterList::getFullInterfaceType(getterType, params,
539-
importedDecl));
549+
550+
auto type = ParameterList::getFullInterfaceType(getterType, params,
551+
importedDecl);
552+
getterDecl->setType(type);
553+
getterDecl->setInterfaceType(type);
554+
540555
getterDecl->setBodyResultType(getterType);
541556

542557
return getterDecl;
@@ -569,8 +584,11 @@ static FuncDecl *makeFieldSetterDecl(ClangImporter::Implementation &Impl,
569584
/*GenericParams=*/nullptr, params, Type(),
570585
TypeLoc::withoutLoc(voidTy), importedDecl, clangNode);
571586

572-
setterDecl->setType(ParameterList::getFullInterfaceType(voidTy, params,
573-
importedDecl));
587+
auto type = ParameterList::getFullInterfaceType(voidTy, params,
588+
importedDecl);
589+
setterDecl->setType(type);
590+
setterDecl->setInterfaceType(type);
591+
574592
setterDecl->setBodyResultType(voidTy);
575593
setterDecl->setAccessibility(Accessibility::Public);
576594
setterDecl->setMutating();
@@ -961,6 +979,7 @@ static bool addErrorDomain(NominalTypeDecl *swiftDecl,
961979
/*AccessorKeywordLoc=*/SourceLoc(),
962980
/*GenericParams=*/nullptr, params, toStringTy,
963981
TypeLoc::withoutLoc(stringTy), swiftDecl);
982+
getterDecl->setInterfaceType(toStringTy);
964983

965984
// Make the property decl
966985
auto errorDomainPropertyDecl = new (C) VarDecl(
@@ -1693,7 +1712,8 @@ namespace {
16931712
auto allocFnTy = FunctionType::get(selfMetatype, fnTy);
16941713
auto initFnTy = FunctionType::get(selfType, fnTy);
16951714
constructor->setType(allocFnTy);
1696-
constructor->setInitializerType(initFnTy);
1715+
constructor->setInterfaceType(allocFnTy);
1716+
constructor->setInitializerInterfaceType(initFnTy);
16971717

16981718
constructor->setAccessibility(Accessibility::Public);
16991719

@@ -1949,7 +1969,8 @@ namespace {
19491969
auto allocFnTy = FunctionType::get(selfMetatype, fnTy);
19501970
auto initFnTy = FunctionType::get(selfType, fnTy);
19511971
constructor->setType(allocFnTy);
1952-
constructor->setInitializerType(initFnTy);
1972+
constructor->setInterfaceType(allocFnTy);
1973+
constructor->setInitializerInterfaceType(initFnTy);
19531974

19541975
constructor->setAccessibility(Accessibility::Public);
19551976

@@ -2885,9 +2906,12 @@ namespace {
28852906
Type argType = parameterList->getType(Impl.SwiftContext);
28862907
Type fnType = FunctionType::get(argType, resultType);
28872908
Type selfType = selfParam->getType();
2888-
result->setInitializerType(FunctionType::get(selfType, fnType));
2909+
Type initType = FunctionType::get(selfType, fnType);
2910+
result->setInitializerInterfaceType(initType);
28892911
Type selfMetaType = MetatypeType::get(selfType->getInOutObjectType());
2890-
result->setType(FunctionType::get(selfMetaType, fnType));
2912+
Type allocType = FunctionType::get(selfMetaType, fnType);
2913+
result->setType(allocType);
2914+
result->setInterfaceType(allocType);
28912915

28922916
finishFuncDecl(decl, result);
28932917
return result;
@@ -2951,16 +2975,12 @@ namespace {
29512975
/*GenericParams=*/nullptr, bodyParams, Type(),
29522976
TypeLoc::withoutLoc(swiftResultTy), dc, decl);
29532977

2954-
if (auto proto = dc->getAsProtocolOrProtocolExtensionContext()) {
2955-
Type interfaceType;
2956-
std::tie(fnType, interfaceType) =
2957-
getGenericMethodType(proto, fnType->castTo<AnyFunctionType>());
2958-
result->setType(fnType);
2959-
result->setInterfaceType(interfaceType);
2960-
result->setGenericSignature(proto->getGenericSignature());
2961-
} else {
2962-
result->setType(fnType);
2963-
}
2978+
Type interfaceType;
2979+
std::tie(fnType, interfaceType) =
2980+
getGenericMethodType(dc, fnType->castTo<AnyFunctionType>());
2981+
result->setType(fnType);
2982+
result->setInterfaceType(interfaceType);
2983+
result->setGenericSignature(dc->getGenericSignatureOfContext());
29642984

29652985
result->setBodyResultType(swiftResultTy);
29662986
result->setAccessibility(Accessibility::Public);
@@ -3250,6 +3270,7 @@ namespace {
32503270
/*GenericParams=*/nullptr, bodyParams, type,
32513271
TypeLoc::withoutLoc(resultTy), dc, decl);
32523272

3273+
result->setInterfaceType(type);
32533274
result->setBodyResultType(resultTy);
32543275

32553276
result->setAccessibility(Accessibility::Public);
@@ -3734,10 +3755,8 @@ namespace {
37343755
// Add the 'self' parameter to the function type.
37353756
type = FunctionType::get(selfInterfaceType, type);
37363757

3737-
if (dc->isGenericContext()) {
3738-
std::tie(type, interfaceType)
3739-
= getGenericMethodType(dc, type->castTo<AnyFunctionType>());
3740-
}
3758+
std::tie(type, interfaceType)
3759+
= getGenericMethodType(dc, type->castTo<AnyFunctionType>());
37413760

37423761
result->setBodyResultType(resultTy);
37433762
result->setType(type);
@@ -4207,21 +4226,18 @@ namespace {
42074226
addObjCAttribute(result, selector);
42084227

42094228
// Calculate the function type of the result.
4210-
if (dc->isGenericContext()) {
4211-
Type interfaceAllocType;
4212-
Type interfaceInitType;
4213-
std::tie(allocType, interfaceAllocType)
4214-
= getGenericMethodType(dc, allocType->castTo<AnyFunctionType>());
4215-
std::tie(initType, interfaceInitType)
4216-
= getGenericMethodType(dc, initType->castTo<AnyFunctionType>());
4217-
4218-
result->setInitializerInterfaceType(interfaceInitType);
4219-
result->setInterfaceType(interfaceAllocType);
4220-
result->setGenericSignature(dc->getGenericSignatureOfContext());
4221-
}
4229+
Type interfaceAllocType;
4230+
Type interfaceInitType;
4231+
std::tie(allocType, interfaceAllocType)
4232+
= getGenericMethodType(dc, allocType->castTo<AnyFunctionType>());
4233+
std::tie(initType, interfaceInitType)
4234+
= getGenericMethodType(dc, initType->castTo<AnyFunctionType>());
4235+
4236+
result->setInitializerInterfaceType(interfaceInitType);
4237+
result->setInterfaceType(interfaceAllocType);
4238+
result->setGenericSignature(dc->getGenericSignatureOfContext());
42224239

42234240
result->setType(allocType);
4224-
result->setInitializerType(initType);
42254241

42264242
if (implicit)
42274243
result->setImplicit();
@@ -4305,6 +4321,10 @@ namespace {
43054321
AnyFunctionType *fnType) {
43064322
assert(!fnType->hasArchetype());
43074323

4324+
auto *sig = dc->getGenericSignatureOfContext();
4325+
if (!sig)
4326+
return { fnType, fnType };
4327+
43084328
Type inputType = ArchetypeBuilder::mapTypeIntoContext(
43094329
dc, fnType->getInput());
43104330
Type resultType = ArchetypeBuilder::mapTypeIntoContext(
@@ -4313,7 +4333,7 @@ namespace {
43134333
dc->getGenericParamsOfContext());
43144334

43154335
Type interfaceType = GenericFunctionType::get(
4316-
dc->getGenericSignatureOfContext(),
4336+
sig,
43174337
fnType->getInput(), fnType->getResult(),
43184338
AnyFunctionType::ExtInfo());
43194339

@@ -4338,10 +4358,8 @@ namespace {
43384358
ParameterList::getFullInterfaceType(elementTy, getterArgs, dc);
43394359

43404360
Type interfaceType;
4341-
if (dc->isGenericContext()) {
4342-
std::tie(getterType, interfaceType)
4343-
= getGenericMethodType(dc, getterType->castTo<AnyFunctionType>());
4344-
}
4361+
std::tie(getterType, interfaceType)
4362+
= getGenericMethodType(dc, getterType->castTo<AnyFunctionType>());
43454363

43464364
// Create the getter thunk.
43474365
FuncDecl *thunk = FuncDecl::create(
@@ -4409,10 +4427,8 @@ namespace {
44094427
dc);
44104428

44114429
Type interfaceType;
4412-
if (dc->isGenericContext()) {
4413-
std::tie(setterType, interfaceType)
4414-
= getGenericMethodType(dc, setterType->castTo<AnyFunctionType>());
4415-
}
4430+
std::tie(setterType, interfaceType)
4431+
= getGenericMethodType(dc, setterType->castTo<AnyFunctionType>());
44164432

44174433
// Create the setter thunk.
44184434
FuncDecl *thunk = FuncDecl::create(
@@ -4769,8 +4785,12 @@ namespace {
47694785
subscript->makeComputed(SourceLoc(), getterThunk, setterThunk, nullptr,
47704786
SourceLoc());
47714787
auto indicesType = bodyParams->getType(C);
4772-
4773-
subscript->setType(FunctionType::get(indicesType, elementTy)); // TODO: no good when generics are around
4788+
4789+
// TODO: no good when generics are around
4790+
auto fnType = FunctionType::get(indicesType, elementTy);
4791+
subscript->setType(fnType);
4792+
subscript->setInterfaceType(fnType);
4793+
47744794
addObjCAttribute(subscript, None);
47754795

47764796
// Optional subscripts in protocols.
@@ -6898,6 +6918,7 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
68986918
/*GenericParams=*/nullptr, getterArgs,
68996919
getterType, TypeLoc::withoutLoc(type), dc);
69006920
func->setStatic(isStatic);
6921+
func->setInterfaceType(getterType);
69016922
func->setBodyResultType(type);
69026923
func->setAccessibility(Accessibility::Public);
69036924

‎lib/Parse/ParseDecl.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3825,6 +3825,7 @@ void Parser::ParsedAccessors::record(Parser &P, AbstractStorageDecl *storage,
38253825
auto flagInvalidAccessor = [&](FuncDecl *&func) {
38263826
if (func) {
38273827
func->setType(ErrorType::get(P.Context));
3828+
func->setInterfaceType(ErrorType::get(P.Context));
38283829
func->setInvalid();
38293830
}
38303831
};

‎lib/Sema/CSApply.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1309,8 +1309,8 @@ namespace {
13091309

13101310
// Compute the concrete reference.
13111311
ConcreteDeclRef ref;
1312-
Type resultTy;
1313-
if (ctor->getInterfaceType()->is<GenericFunctionType>()) {
1312+
Type resultTy = ctor->getInitializerInterfaceType();
1313+
if (resultTy->is<GenericFunctionType>()) {
13141314
// Compute the reference to the generic constructor.
13151315
SmallVector<Substitution, 4> substitutions;
13161316
resultTy = solution.computeSubstitutions(
@@ -1333,7 +1333,6 @@ namespace {
13331333
resultFnTy->getExtInfo());
13341334
} else {
13351335
ref = ConcreteDeclRef(ctor);
1336-
resultTy = ctor->getInitializerType();
13371336
}
13381337

13391338
// Build the constructor reference.
@@ -2183,7 +2182,8 @@ namespace {
21832182
}
21842183

21852184
Expr *visitOtherConstructorDeclRefExpr(OtherConstructorDeclRefExpr *expr) {
2186-
expr->setType(expr->getDecl()->getInitializerType());
2185+
assert(!expr->getDeclRef().isSpecialized());
2186+
expr->setType(expr->getDecl()->getInitializerInterfaceType());
21872187
return expr;
21882188
}
21892189

‎lib/Sema/CodeSynthesis.cpp

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2142,10 +2142,8 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
21422142
auto selfType = configureImplicitSelf(tc, ctor);
21432143

21442144
// Set the interface type of the initializer.
2145-
if (classDecl->isGenericContext()) {
2146-
ctor->setGenericSignature(classDecl->getGenericSignatureOfContext());
2147-
tc.configureInterfaceType(ctor);
2148-
}
2145+
ctor->setGenericSignature(classDecl->getGenericSignatureOfContext());
2146+
tc.configureInterfaceType(ctor);
21492147

21502148
// Set the contextual type of the initializer. This will go away one day.
21512149
configureConstructorType(ctor, selfType, bodyParams->getType(ctx));

‎lib/Sema/DerivedConformanceRawRepresentable.cpp

Lines changed: 2 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -305,16 +305,11 @@ static ConstructorDecl *deriveRawRepresentable_init(TypeChecker &tc,
305305
Type selfMetatype = MetatypeType::get(selfType->getInOutObjectType());
306306

307307
Type allocType;
308-
Type initType;
309-
if (genericParams) {
308+
if (genericParams)
310309
allocType = PolymorphicFunctionType::get(selfMetatype, type, genericParams);
311-
initType = PolymorphicFunctionType::get(selfType, type, genericParams);
312-
} else {
310+
else
313311
allocType = FunctionType::get(selfMetatype, type);
314-
initType = FunctionType::get(selfType, type);
315-
}
316312
initDecl->setType(allocType);
317-
initDecl->setInitializerType(initType);
318313

319314
// Compute the interface type of the initializer.
320315
Type retInterfaceType

0 commit comments

Comments
 (0)