Skip to content

Commit 3d4541d

Browse files
slavapestovslavapestov
authored
Merge pull request swiftlang#25009 from slavapestov/type-checked-constants
ClangImporter: Build type-checked AST for constants
2 parents b13bfc6 + 8075b09 commit 3d4541d

File tree

8 files changed

+265
-61
lines changed

8 files changed

+265
-61
lines changed

‎include/swift/AST/ASTContext.h

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@ namespace swift {
5353
class AvailabilityContext;
5454
class BoundGenericType;
5555
class ClangNode;
56+
class ConcreteDeclRef;
5657
class ConstructorDecl;
5758
class Decl;
5859
class DeclContext;
@@ -514,7 +515,20 @@ class ASTContext final {
514515
bool hasArrayLiteralIntrinsics() const;
515516

516517
/// Retrieve the declaration of Swift.Bool.init(_builtinBooleanLiteral:)
517-
ConstructorDecl *getBoolBuiltinInitDecl() const;
518+
ConcreteDeclRef getBoolBuiltinInitDecl() const;
519+
520+
/// Retrieve the witness for init(_builtinIntegerLiteral:).
521+
ConcreteDeclRef getIntBuiltinInitDecl(NominalTypeDecl *intDecl) const;
522+
523+
/// Retrieve the witness for init(_builtinFloatLiteral:).
524+
ConcreteDeclRef getFloatBuiltinInitDecl(NominalTypeDecl *floatDecl) const;
525+
526+
/// Retrieve the witness for (_builtinStringLiteral:utf8CodeUnitCount:isASCII:).
527+
ConcreteDeclRef getStringBuiltinInitDecl(NominalTypeDecl *stringDecl) const;
528+
529+
ConcreteDeclRef getBuiltinInitDecl(NominalTypeDecl *decl,
530+
KnownProtocolKind builtinProtocol,
531+
llvm::function_ref<DeclName (ASTContext &ctx)> initName) const;
518532

519533
/// Retrieve the declaration of Swift.==(Int, Int) -> Bool.
520534
FuncDecl *getEqualIntDecl() const;

‎include/swift/AST/KnownStdlibTypes.def

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,7 @@ KNOWN_STDLIB_TYPE_DECL(Float80, NominalTypeDecl, 0)
4848
KNOWN_STDLIB_TYPE_DECL(_MaxBuiltinFloatType, TypeAliasDecl, 0)
4949

5050
KNOWN_STDLIB_TYPE_DECL(String, NominalTypeDecl, 0)
51+
KNOWN_STDLIB_TYPE_DECL(StaticString, NominalTypeDecl, 0)
5152
KNOWN_STDLIB_TYPE_DECL(Substring, NominalTypeDecl, 0)
5253
KNOWN_STDLIB_TYPE_DECL(Array, NominalTypeDecl, 1)
5354
KNOWN_STDLIB_TYPE_DECL(Set, NominalTypeDecl, 1)

‎lib/AST/ASTContext.cpp

Lines changed: 72 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -183,9 +183,6 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
183183
#define FUNC_DECL(Name, Id) FuncDecl *Get##Name = nullptr;
184184
#include "swift/AST/KnownDecls.def"
185185

186-
/// Swift.Bool.init(_builtinBooleanLiteral:)
187-
ConstructorDecl *BoolBuiltinInitDecl = nullptr;
188-
189186
/// func ==(Int, Int) -> Bool
190187
FuncDecl *EqualIntDecl = nullptr;
191188

@@ -277,6 +274,10 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
277274
/// to the original property with the delegate.
278275
llvm::DenseMap<const VarDecl *, VarDecl *> OriginalDelegatedProperties;
279276

277+
/// The builtin initializer witness for a literal. Used when building
278+
/// LiteralExprs in fully-checked AST.
279+
llvm::DenseMap<const NominalTypeDecl *, ConcreteDeclRef> BuiltinInitWitness;
280+
280281
/// Structure that captures data that is segregated into different
281282
/// arenas.
282283
struct Arena {
@@ -963,27 +964,80 @@ lookupOperatorFunc(const ASTContext &ctx, StringRef oper, Type contextType,
963964
return nullptr;
964965
}
965966

966-
ConstructorDecl *ASTContext::getBoolBuiltinInitDecl() const {
967-
if (getImpl().BoolBuiltinInitDecl)
968-
return getImpl().BoolBuiltinInitDecl;
967+
ConcreteDeclRef ASTContext::getBoolBuiltinInitDecl() const {
968+
auto fn = [&](ASTContext &ctx) {
969+
return DeclName(ctx, DeclBaseName::createConstructor(),
970+
{ Id_builtinBooleanLiteral });
971+
};
972+
auto builtinProtocolKind =
973+
KnownProtocolKind::ExpressibleByBuiltinBooleanLiteral;
974+
return getBuiltinInitDecl(getBoolDecl(), builtinProtocolKind, fn);
975+
}
969976

970-
if (!getBoolDecl())
971-
return nullptr;
977+
ConcreteDeclRef
978+
ASTContext::getIntBuiltinInitDecl(NominalTypeDecl *intDecl) const {
979+
auto fn = [&](ASTContext &ctx) {
980+
return DeclName(ctx, DeclBaseName::createConstructor(),
981+
{ Id_builtinIntegerLiteral });
982+
};
983+
auto builtinProtocolKind =
984+
KnownProtocolKind::ExpressibleByBuiltinIntegerLiteral;
985+
return getBuiltinInitDecl(intDecl, builtinProtocolKind, fn);
986+
}
972987

973-
DeclName initName(*const_cast<ASTContext *>(this),
974-
DeclBaseName::createConstructor(),
975-
{ Id_builtinBooleanLiteral });
976-
auto members = getBoolDecl()->lookupDirect(initName);
988+
ConcreteDeclRef
989+
ASTContext::getFloatBuiltinInitDecl(NominalTypeDecl *floatDecl) const {
990+
auto fn = [&](ASTContext &ctx) {
991+
return DeclName(ctx, DeclBaseName::createConstructor(),
992+
{ Id_builtinFloatLiteral });
993+
};
977994

978-
if (members.size() != 1)
979-
return nullptr;
995+
auto builtinProtocolKind =
996+
KnownProtocolKind::ExpressibleByBuiltinFloatLiteral;
997+
return getBuiltinInitDecl(floatDecl, builtinProtocolKind, fn);
998+
}
999+
1000+
ConcreteDeclRef
1001+
ASTContext::getStringBuiltinInitDecl(NominalTypeDecl *stringDecl) const {
1002+
auto fn = [&](ASTContext &ctx) {
1003+
return DeclName(ctx, DeclBaseName::createConstructor(),
1004+
{ Id_builtinStringLiteral,
1005+
getIdentifier("utf8CodeUnitCount"),
1006+
getIdentifier("isASCII") });
1007+
};
1008+
1009+
auto builtinProtocolKind =
1010+
KnownProtocolKind::ExpressibleByBuiltinStringLiteral;
1011+
return getBuiltinInitDecl(stringDecl, builtinProtocolKind, fn);
1012+
}
1013+
1014+
ConcreteDeclRef
1015+
ASTContext::getBuiltinInitDecl(NominalTypeDecl *decl,
1016+
KnownProtocolKind builtinProtocolKind,
1017+
llvm::function_ref<DeclName (ASTContext &ctx)> initName) const {
1018+
auto &witness = getImpl().BuiltinInitWitness[decl];
1019+
if (witness)
1020+
return witness;
9801021

981-
if (auto init = dyn_cast<ConstructorDecl>(members[0])) {
982-
getImpl().BoolBuiltinInitDecl = init;
983-
return init;
1022+
auto type = decl->getDeclaredType();
1023+
auto builtinProtocol = getProtocol(builtinProtocolKind);
1024+
auto builtinConformance = getStdlibModule()->lookupConformance(
1025+
type, builtinProtocol);
1026+
if (!builtinConformance) {
1027+
assert(false && "Missing required conformance");
1028+
witness = ConcreteDeclRef();
1029+
return witness;
9841030
}
9851031

986-
return nullptr;
1032+
auto *ctx = const_cast<ASTContext *>(this);
1033+
witness = builtinConformance->getWitnessByName(type, initName(*ctx));
1034+
if (!witness) {
1035+
assert(false && "Missing required witness");
1036+
witness = ConcreteDeclRef();
1037+
return witness;
1038+
}
1039+
1040+
return witness;
9871041
}
9881042

9891043
FuncDecl *ASTContext::getEqualIntDecl() const {

‎lib/ClangImporter/ImportDecl.cpp

Lines changed: 110 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1001,6 +1001,7 @@ makeUnionFieldAccessors(ClangImporter::Implementation &Impl,
10011001
{ inoutSelf },
10021002
{ Identifier() });
10031003
selfPointer->setType(C.TheRawPointerType);
1004+
selfPointer->setThrows(false);
10041005

10051006
auto initializeFn = cast<FuncDecl>(getBuiltinValueDecl(
10061007
C, C.getIdentifier("initialize")));
@@ -1018,6 +1019,7 @@ makeUnionFieldAccessors(ClangImporter::Implementation &Impl,
10181019
{ newValueRef, selfPointer },
10191020
{ Identifier(), Identifier() });
10201021
initialize->setType(TupleType::getEmpty(C));
1022+
initialize->setThrows(false);
10211023

10221024
auto body = BraceStmt::create(C, SourceLoc(), { initialize }, SourceLoc(),
10231025
/*implicit*/ true);
@@ -1499,15 +1501,19 @@ static void makeStructRawValued(
14991501
createValueConstructor(Impl, structDecl, var,
15001502
/*wantCtorParamNames=*/false,
15011503
/*wantBody=*/!Impl.hasFinishedTypeChecking()));
1502-
structDecl->addMember(
1504+
1505+
auto *initRawValue =
15031506
createValueConstructor(Impl, structDecl, var,
15041507
/*wantCtorParamNames=*/true,
1505-
/*wantBody=*/!Impl.hasFinishedTypeChecking()));
1508+
/*wantBody=*/!Impl.hasFinishedTypeChecking());
1509+
structDecl->addMember(initRawValue);
15061510
structDecl->addMember(patternBinding);
15071511
structDecl->addMember(var);
15081512
structDecl->addMember(varGetter);
15091513

15101514
addSynthesizedTypealias(structDecl, ctx.Id_RawValue, underlyingType);
1515+
Impl.RawTypes[structDecl] = underlyingType;
1516+
Impl.RawInits[structDecl] = initRawValue;
15111517
}
15121518

15131519
/// Create a rawValue-ed constructor that bridges to its underlying storage.
@@ -1650,6 +1656,8 @@ static void makeStructRawValuedWithBridge(
16501656
structDecl->addMember(computedVarGetter);
16511657

16521658
addSynthesizedTypealias(structDecl, ctx.Id_RawValue, bridgedType);
1659+
Impl.RawTypes[structDecl] = bridgedType;
1660+
Impl.RawInits[structDecl] = init;
16531661
}
16541662

16551663
/// Build a declaration for an Objective-C subscript getter.
@@ -2852,6 +2860,8 @@ namespace {
28522860
enumDecl->addMember(rawValueBinding);
28532861

28542862
addSynthesizedTypealias(enumDecl, C.Id_RawValue, underlyingType);
2863+
Impl.RawTypes[enumDecl] = underlyingType;
2864+
Impl.RawInits[enumDecl] = rawValueConstructor;
28552865

28562866
// If we have an error wrapper, finish it up now that its
28572867
// nested enum has been constructed.
@@ -3381,7 +3391,7 @@ namespace {
33813391
// Create the global constant.
33823392
auto result = Impl.createConstant(name, dc, type,
33833393
clang::APValue(decl->getInitVal()),
3384-
ConstantConvertKind::Coerce,
3394+
ConstantConvertKind::None,
33853395
/*static*/dc->isTypeContext(), decl);
33863396
Impl.ImportedDecls[{decl->getCanonicalDecl(), getVersion()}] = result;
33873397

@@ -5546,11 +5556,15 @@ Decl *SwiftDeclConverter::importEnumCaseAlias(
55465556
auto constantRef =
55475557
new (Impl.SwiftContext) DeclRefExpr(original, DeclNameLoc(),
55485558
/*implicit*/ true);
5559+
constantRef->setType(original->getInterfaceType());
5560+
55495561
Type importedEnumTy = importedEnum->getDeclaredInterfaceType();
5562+
55505563
auto typeRef = TypeExpr::createImplicit(importedEnumTy, Impl.SwiftContext);
55515564
auto instantiate = new (Impl.SwiftContext)
55525565
DotSyntaxCallExpr(constantRef, SourceLoc(), typeRef);
55535566
instantiate->setType(importedEnumTy);
5567+
instantiate->setThrows(false);
55545568

55555569
Decl *CD = Impl.createConstant(name, importIntoDC, importedEnumTy,
55565570
instantiate, ConstantConvertKind::None,
@@ -8139,6 +8153,21 @@ ClangImporter::Implementation::importDeclContextOf(
81398153
return ext;
81408154
}
81418155

8156+
static Type getConstantLiteralType(ClangImporter::Implementation &Impl,
8157+
Type type, ConstantConvertKind convertKind) {
8158+
switch (convertKind) {
8159+
case ConstantConvertKind::Construction:
8160+
case ConstantConvertKind::ConstructionWithUnwrap: {
8161+
auto found = Impl.RawTypes.find(type->getAnyNominal());
8162+
assert(found != Impl.RawTypes.end());
8163+
return found->second;
8164+
}
8165+
8166+
default:
8167+
return type;
8168+
}
8169+
}
8170+
81428171
ValueDecl *
81438172
ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
81448173
Type type,
@@ -8180,20 +8209,49 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
81808209
if (isNegative)
81818210
printedValue = printedValue.drop_front();
81828211

8212+
auto literalType = getConstantLiteralType(*this, type, convertKind);
8213+
81838214
// Create the expression node.
81848215
StringRef printedValueCopy(context.AllocateCopy(printedValue));
81858216
if (value.getKind() == clang::APValue::Int) {
81868217
if (type->getCanonicalType()->isBool()) {
8187-
expr = new (context) BooleanLiteralExpr(value.getInt().getBoolValue(),
8188-
SourceLoc(),
8189-
/**Implicit=*/true);
8218+
auto *boolExpr =
8219+
new (context) BooleanLiteralExpr(value.getInt().getBoolValue(),
8220+
SourceLoc(),
8221+
/**Implicit=*/true);
8222+
8223+
boolExpr->setBuiltinInitializer(
8224+
context.getBoolBuiltinInitDecl());
8225+
boolExpr->setType(literalType);
8226+
8227+
expr = boolExpr;
81908228
} else {
8191-
expr = new (context) IntegerLiteralExpr(printedValueCopy, SourceLoc(),
8192-
/*Implicit=*/true);
8229+
auto *intExpr =
8230+
new (context) IntegerLiteralExpr(printedValueCopy, SourceLoc(),
8231+
/*Implicit=*/true);
8232+
8233+
auto *intDecl = literalType->getAnyNominal();
8234+
intExpr->setBuiltinInitializer(
8235+
context.getIntBuiltinInitDecl(intDecl));
8236+
intExpr->setType(literalType);
8237+
8238+
expr = intExpr;
81938239
}
81948240
} else {
8195-
expr = new (context) FloatLiteralExpr(printedValueCopy, SourceLoc(),
8196-
/*Implicit=*/true);
8241+
auto *floatExpr =
8242+
new (context) FloatLiteralExpr(printedValueCopy, SourceLoc(),
8243+
/*Implicit=*/true);
8244+
8245+
auto maxFloatTypeDecl = context.get_MaxBuiltinFloatTypeDecl();
8246+
floatExpr->setBuiltinType(
8247+
maxFloatTypeDecl->getUnderlyingTypeLoc().getType());
8248+
8249+
auto *floatDecl = literalType->getAnyNominal();
8250+
floatExpr->setBuiltinInitializer(
8251+
context.getFloatBuiltinInitDecl(floatDecl));
8252+
floatExpr->setType(literalType);
8253+
8254+
expr = floatExpr;
81978255
}
81988256

81998257
if (isNegative)
@@ -8215,6 +8273,13 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
82158273
bool isStatic,
82168274
ClangNode ClangN) {
82178275
auto expr = new (SwiftContext) StringLiteralExpr(value, SourceRange());
8276+
8277+
auto literalType = getConstantLiteralType(*this, type, convertKind);
8278+
auto *stringDecl = literalType->getAnyNominal();
8279+
expr->setBuiltinInitializer(
8280+
SwiftContext.getStringBuiltinInitDecl(stringDecl));
8281+
expr->setType(literalType);
8282+
82188283
return createConstant(name, dc, type, expr, convertKind, isStatic, ClangN);
82198284
}
82208285

@@ -8279,20 +8344,42 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
82798344
case ConstantConvertKind::Construction:
82808345
case ConstantConvertKind::ConstructionWithUnwrap: {
82818346
auto typeRef = TypeExpr::createImplicit(type, C);
8282-
8283-
expr = CallExpr::createImplicit(C, typeRef, { expr }, { C.Id_rawValue });
8284-
if (convertKind == ConstantConvertKind::ConstructionWithUnwrap)
8285-
expr = new (C) ForceValueExpr(expr, SourceLoc());
8286-
break;
8287-
}
82888347

8289-
case ConstantConvertKind::Coerce:
8290-
break;
8348+
// Reference init(rawValue: T)
8349+
auto found = RawInits.find(type->getAnyNominal());
8350+
assert(found != RawInits.end());
8351+
8352+
auto *init = found->second;
8353+
auto initTy = init->getInterfaceType()->removeArgumentLabels(1);
8354+
auto declRef =
8355+
new (C) DeclRefExpr(init, DeclNameLoc(), /*Implicit=*/true,
8356+
AccessSemantics::Ordinary, initTy);
8357+
8358+
// (Self) -> ...
8359+
initTy = initTy->castTo<FunctionType>()->getResult();
8360+
auto initRef = new (C) DotSyntaxCallExpr(declRef, SourceLoc(),
8361+
typeRef, initTy);
8362+
initRef->setThrows(false);
8363+
8364+
// (rawValue: T) -> ...
8365+
initTy = initTy->castTo<FunctionType>()->getResult();
8366+
8367+
auto initCall = CallExpr::createImplicit(C, initRef, { expr },
8368+
{ C.Id_rawValue });
8369+
initCall->setType(initTy);
8370+
initCall->setThrows(false);
8371+
8372+
expr = initCall;
8373+
8374+
// Force unwrap if our init(rawValue:) is failable, which is currently
8375+
// the case with enums.
8376+
if (convertKind == ConstantConvertKind::ConstructionWithUnwrap) {
8377+
initTy = initTy->getOptionalObjectType();
8378+
expr = new (C) ForceValueExpr(expr, SourceLoc());
8379+
expr->setType(initTy);
8380+
}
82918381

8292-
case ConstantConvertKind::Downcast: {
8293-
expr = new (C) ForcedCheckedCastExpr(expr, SourceLoc(), SourceLoc(),
8294-
TypeLoc::withoutLoc(type));
8295-
expr->setImplicit();
8382+
assert(initTy->isEqual(type));
82968383
break;
82978384
}
82988385
}
@@ -8304,6 +8391,7 @@ ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
83048391
func->setBody(BraceStmt::create(C, SourceLoc(),
83058392
ASTNode(ret),
83068393
SourceLoc()));
8394+
func->setBodyTypeCheckedIfPresent();
83078395
}
83088396

83098397
// Mark the function transparent so that we inline it away completely.

0 commit comments

Comments
 (0)