Skip to content

Commit ed38036

Browse files
kubamracekkubamracek
committed
SE-0492: Metatypes and existential metatypes
1 parent 4432378 commit ed38036

File tree

11 files changed

+212
-12
lines changed

11 files changed

+212
-12
lines changed

‎SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -462,6 +462,19 @@ extension Instruction {
462462
}
463463
case let gvi as GlobalValueInst:
464464
return context.canMakeStaticObjectReadOnly(objectType: gvi.type)
465+
466+
// Metatypes (and upcasts of them to existentials) can be used as static initializers for SE-0492, as long as they
467+
// are not generic or resilient
468+
case let mti as MetatypeInst:
469+
if !mti.type.hasTypeParameter,
470+
let nominal = mti.type.canonicalType.instanceTypeOfMetatype.nominal,
471+
!nominal.isResilient(in: mti.parentFunction) {
472+
return true
473+
}
474+
return false
475+
case let iemi as InitExistentialMetatypeInst:
476+
return !iemi.type.hasTypeParameter
477+
465478
case is StructInst,
466479
is TupleInst,
467480
is EnumInst,

‎include/swift/SIL/SILBuilder.h‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2155,6 +2155,11 @@ class SILBuilder {
21552155
createInitExistentialMetatype(SILLocation Loc, SILValue metatype,
21562156
SILType existentialType,
21572157
ArrayRef<ProtocolConformanceRef> conformances) {
2158+
if (isInsertingIntoGlobal()) {
2159+
return insert(InitExistentialMetatypeInst::create(
2160+
getSILDebugLocation(Loc), existentialType, metatype, conformances,
2161+
getModule()));
2162+
}
21582163
return insert(InitExistentialMetatypeInst::create(
21592164
getSILDebugLocation(Loc), existentialType, metatype, conformances,
21602165
&getFunction()));
@@ -2289,6 +2294,10 @@ class SILBuilder {
22892294
}
22902295

22912296
MetatypeInst *createMetatype(SILLocation Loc, SILType Metatype) {
2297+
if (isInsertingIntoGlobal()) {
2298+
return insert(MetatypeInst::create(getSILDebugLocation(Loc), Metatype,
2299+
getModule()));
2300+
}
22922301
return insert(MetatypeInst::create(getSILDebugLocation(Loc), Metatype,
22932302
&getFunction()));
22942303
}

‎include/swift/SIL/SILInstruction.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7464,6 +7464,9 @@ class MetatypeInst final
74647464
ArrayRef<SILValue> TypeDependentOperands)
74657465
: NullaryInstructionWithTypeDependentOperandsBase(DebugLoc,
74667466
TypeDependentOperands, Metatype) {}
7467+
7468+
static MetatypeInst *create(SILDebugLocation DebugLoc, SILType Metatype,
7469+
SILModule &Mod);
74677470

74687471
static MetatypeInst *create(SILDebugLocation DebugLoc, SILType Metatype,
74697472
SILFunction *F);
@@ -8141,6 +8144,11 @@ class InitExistentialMetatypeInst final
81418144
ArrayRef<SILValue> TypeDependentOperands,
81428145
ArrayRef<ProtocolConformanceRef> conformances);
81438146

8147+
static InitExistentialMetatypeInst *
8148+
create(SILDebugLocation DebugLoc, SILType existentialMetatypeType,
8149+
SILValue metatype, ArrayRef<ProtocolConformanceRef> conformances,
8150+
SILModule &mod);
8151+
81448152
static InitExistentialMetatypeInst *
81458153
create(SILDebugLocation DebugLoc, SILType existentialMetatypeType,
81468154
SILValue metatype, ArrayRef<ProtocolConformanceRef> conformances,

‎lib/IRGen/GenConstant.cpp‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
#include "Explosion.h"
2121
#include "GenConstant.h"
2222
#include "GenEnum.h"
23+
#include "GenExistential.h"
2324
#include "GenIntegerLiteral.h"
2425
#include "GenStruct.h"
2526
#include "GenTuple.h"
@@ -31,9 +32,11 @@
3132
#include "swift/IRGen/Linking.h"
3233
#include "swift/Basic/Assertions.h"
3334
#include "swift/Basic/Range.h"
35+
#include "swift/SIL/SILInstruction.h"
3436
#include "swift/SIL/SILModule.h"
3537
#include "llvm/Analysis/ConstantFolding.h"
3638
#include "llvm/Support/BLAKE3.h"
39+
#include "llvm/Support/ErrorHandling.h"
3740

3841
using namespace swift;
3942
using namespace irgen;
@@ -414,6 +417,24 @@ Explosion irgen::emitConstantValue(IRGenModule &IGM, SILValue operand,
414417
assert(ti.isFixedSize(expansion));
415418
Address addr = IGM.getAddrOfSILGlobalVariable(var, ti, NotForDefinition);
416419
return addr.getAddress();
420+
} else if (auto *mti = dyn_cast<MetatypeInst>(operand)) {
421+
auto metaTy = mti->getType().castTo<MetatypeType>();
422+
auto type = metaTy.getInstanceType();
423+
return IGM.getAddrOfTypeMetadata(type);
424+
} else if (auto *iemi = dyn_cast<InitExistentialMetatypeInst>(operand)) {
425+
auto *mti =
426+
dyn_cast<MetatypeInst>(iemi->getOperand().getDefiningInstruction());
427+
ASSERT(mti != nullptr && "couldn't constant fold initializer expression");
428+
429+
auto metaTy = mti->getType().castTo<MetatypeType>();
430+
auto type = metaTy.getInstanceType();
431+
llvm::Constant *metatype = IGM.getAddrOfTypeMetadata(type);
432+
433+
Explosion result;
434+
emitExistentialMetatypeContainer(IGM, result, iemi->getType(), metatype,
435+
iemi->getOperand()->getType(),
436+
iemi->getConformances());
437+
return result;
417438
} else if (auto *atp = dyn_cast<AddressToPointerInst>(operand)) {
418439
auto *val = emitConstantValue(IGM, atp->getOperand()).claimNextConstant();
419440
return val;

‎lib/IRGen/GenExistential.cpp‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2033,6 +2033,40 @@ void irgen::emitExistentialMetatypeContainer(IRGenFunction &IGF,
20332033
});
20342034
}
20352035

2036+
/// Emit an existential metatype container from a metatype value as an
2037+
/// explosion of llvm::Constant values (suitable for static initialization).
2038+
void irgen::emitExistentialMetatypeContainer(
2039+
IRGenModule &IGM, Explosion &out, SILType outType, llvm::Constant *metatype,
2040+
SILType metatypeType, ArrayRef<ProtocolConformanceRef> conformances) {
2041+
assert(outType.is<ExistentialMetatypeType>());
2042+
auto &destTI = IGM.getTypeInfo(outType).as<ExistentialMetatypeTypeInfo>();
2043+
out.add(metatype);
2044+
2045+
auto srcType = metatypeType.castTo<MetatypeType>().getInstanceType();
2046+
auto destType = outType.castTo<ExistentialMetatypeType>().getInstanceType();
2047+
while (auto destMetatypeType = dyn_cast<ExistentialMetatypeType>(destType)) {
2048+
destType = destMetatypeType.getInstanceType();
2049+
srcType = cast<AnyMetatypeType>(srcType).getInstanceType();
2050+
}
2051+
2052+
// Emit the witness table pointers as constants.
2053+
for (auto protocol : destTI.getStoredProtocols()) {
2054+
// Find the corresponding conformance
2055+
ProtocolConformanceRef conformance;
2056+
for (auto conf : conformances) {
2057+
if (conf.getProtocol() == protocol) {
2058+
conformance = conf;
2059+
break;
2060+
}
2061+
}
2062+
assert(conformance.isConcrete() && "missing conformance");
2063+
2064+
// Emit witness table constant
2065+
auto table = IGM.getAddrOfWitnessTable(conformance.getConcrete());
2066+
out.add(table);
2067+
}
2068+
}
2069+
20362070
void irgen::emitMetatypeOfOpaqueExistential(IRGenFunction &IGF, Address buffer,
20372071
SILType type, Explosion &out) {
20382072
assert(type.isExistentialType());

‎lib/IRGen/GenExistential.h‎

Lines changed: 15 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@ namespace irgen {
3434
class Address;
3535
class Explosion;
3636
class IRGenFunction;
37+
class IRGenModule;
3738

3839
/// Emit the metadata and witness table initialization for an allocated
3940
/// opaque existential container.
@@ -44,16 +45,20 @@ namespace irgen {
4445
SILType loweredSrcType,
4546
ArrayRef<ProtocolConformanceRef> conformances);
4647

47-
/// Emit an existential metatype container from a metatype value
48-
/// as an explosion.
49-
void emitExistentialMetatypeContainer(IRGenFunction &IGF,
50-
Explosion &out,
51-
SILType outType,
52-
llvm::Value *metatype,
53-
SILType metatypeType,
54-
ArrayRef<ProtocolConformanceRef> conformances);
55-
56-
48+
/// Emit an existential metatype container from a metatype value as an
49+
/// explosion.
50+
void emitExistentialMetatypeContainer(
51+
IRGenFunction &IGF, Explosion &out, SILType outType,
52+
llvm::Value *metatype, SILType metatypeType,
53+
ArrayRef<ProtocolConformanceRef> conformances);
54+
55+
/// Emit an existential metatype container from a metatype value as an
56+
/// explosion of llvm::Constant values (suitable for static initialization).
57+
void emitExistentialMetatypeContainer(
58+
IRGenModule &IGM, Explosion &out, SILType outType,
59+
llvm::Constant *metatype, SILType metatypeType,
60+
ArrayRef<ProtocolConformanceRef> conformances);
61+
5762
/// Emit a class existential container from a class instance value
5863
/// as an explosion.
5964
void emitClassExistentialContainer(IRGenFunction &IGF,

‎lib/SIL/IR/SILInstructions.cpp‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2327,6 +2327,17 @@ InitExistentialMetatypeInst::InitExistentialMetatypeInst(
23272327
getTrailingObjects<ProtocolConformanceRef>());
23282328
}
23292329

2330+
InitExistentialMetatypeInst *InitExistentialMetatypeInst::create(
2331+
SILDebugLocation Loc, SILType existentialMetatypeType, SILValue metatype,
2332+
ArrayRef<ProtocolConformanceRef> conformances, SILModule &M) {
2333+
unsigned size = totalSizeToAlloc<swift::Operand, ProtocolConformanceRef>(
2334+
1, conformances.size());
2335+
void *buffer = M.allocateInst(size, alignof(InitExistentialMetatypeInst));
2336+
return ::new (buffer) InitExistentialMetatypeInst(
2337+
Loc, existentialMetatypeType, metatype,
2338+
{}, conformances);
2339+
}
2340+
23302341
InitExistentialMetatypeInst *InitExistentialMetatypeInst::create(
23312342
SILDebugLocation Loc, SILType existentialMetatypeType, SILValue metatype,
23322343
ArrayRef<ProtocolConformanceRef> conformances, SILFunction *F) {
@@ -2737,6 +2748,13 @@ CheckedCastBranchInst *CheckedCastBranchInst::create(
27372748
Target2Count, forwardingOwnershipKind, preservesOwnership);
27382749
}
27392750

2751+
MetatypeInst *MetatypeInst::create(SILDebugLocation Loc, SILType Ty,
2752+
SILModule &Mod) {
2753+
auto Size = totalSizeToAlloc<swift::Operand>(1);
2754+
auto Buffer = Mod.allocateInst(Size, alignof(MetatypeInst));
2755+
return ::new (Buffer) MetatypeInst(Loc, Ty, {});
2756+
}
2757+
27402758
MetatypeInst *MetatypeInst::create(SILDebugLocation Loc, SILType Ty,
27412759
SILFunction *F) {
27422760
SILModule &Mod = F->getModule();

‎lib/Sema/LegalConstExprVerifier.cpp‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,10 @@
2020
#include "TypeChecker.h"
2121
#include "swift/AST/ASTContext.h"
2222
#include "swift/AST/ASTWalker.h"
23+
#include "swift/AST/Expr.h"
2324
#include "swift/AST/ParameterList.h"
2425
#include "swift/AST/SemanticAttrs.h"
26+
#include "swift/AST/Type.h"
2527
#include "swift/Basic/Assertions.h"
2628
using namespace swift;
2729

@@ -343,6 +345,25 @@ checkSupportedWithSectionAttribute(const Expr *expr,
343345
expressionsToCheck.push_back(identityExpr->getSubExpr());
344346
continue;
345347
}
348+
349+
// Upcasts of metatypes to existential metatypes (e.g. Any.Type)
350+
if (const ErasureExpr *erasureExpr = dyn_cast<ErasureExpr>(expr)) {
351+
if (const DotSelfExpr *dotSelfExpr = dyn_cast<DotSelfExpr>(erasureExpr->getSubExpr())) {
352+
if (const TypeExpr *typeExpr = dyn_cast<TypeExpr>(dotSelfExpr->getSubExpr())) {
353+
auto baseType = typeExpr->getType();
354+
if (baseType && baseType->is<MetatypeType>()) {
355+
auto instanceType = baseType->getMetatypeInstanceType();
356+
if (auto nominal = instanceType->getNominalOrBoundGenericNominal()) {
357+
// Allow non-generic, non-resilient types
358+
if (!nominal->isGeneric() && !nominal->isResilient()) {
359+
continue;
360+
}
361+
}
362+
}
363+
}
364+
}
365+
return std::make_pair(expr, TypeExpression);
366+
}
346367

347368
// Function calls and constructors are not allowed
348369
if (isa<ApplyExpr>(expr))

‎test/ConstValues/SectionIR.swift‎

Lines changed: 13 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,8 +39,14 @@ struct W {
3939
@section("mysection") static let closure7: @convention(c) (Int) -> Int = { x in x * 2 }
4040
}
4141

42-
// metatypes - TODO
43-
//@section("mysection") let metatype1 = Int.self
42+
struct S: Hashable, Sendable {}
43+
44+
// metatypes
45+
@section("mysection") let metatype1 = Int.self
46+
@section("mysection") let metatype2: Any.Type = Int.self
47+
@section("mysection") let metatype3: Any.Type = S.self
48+
@section("mysection") let metatype4: any (Hashable & Sendable).Type = Int.self
49+
@section("mysection") let metatype5: any (Hashable & Sendable).Type = S.self
4450

4551
// tuples
4652
@section("mysection") let tuple1 = (1, 2, 3, 2.718, true) // ok
@@ -76,6 +82,11 @@ struct W {
7682
// CHECK: @"$s9SectionIR8closure6yS2iXCvp" = {{.*}}constant ptr @"$s9SectionIR8closure6yS2iXCvpfiS2icfU_To", section "mysection"
7783
// CHECK: @"$s9SectionIR1WV8closure7yS2iXCvpZ" = {{.*}}constant ptr @"$s9SectionIR1WV8closure7yS2iXCvpZfiS2icfU_To", section "mysection"
7884

85+
// CHECK: @"$s9SectionIR9metatype2ypXpvp" = {{.*}}constant ptr @"$sSiN", section "mysection"
86+
// CHECK: @"$s9SectionIR9metatype3ypXpvp" = {{.*}}constant ptr getelementptr inbounds (<{ ptr, ptr, {{i64|i32}}, ptr }>, ptr @"$s9SectionIR1SVMf", i32 0, i32 2), section "mysection"
87+
// CHECK: @"$s9SectionIR9metatype4SH_s8SendablepXpvp" = {{.*}}constant <{ ptr, ptr }> <{ ptr @"$sSiN", ptr @"$sSiSHsWP" }>, section "mysection"
88+
// CHECK: @"$s9SectionIR9metatype5SH_s8SendablepXpvp" = {{.*}}constant <{ ptr, ptr }> <{ ptr getelementptr inbounds (<{ ptr, ptr, {{i64|i32}}, ptr }>, ptr @"$s9SectionIR1SVMf", i32 0, i32 2), ptr @"$s9SectionIR1SVSHAAWP" }>, section "mysection"
89+
7990
// CHECK: @"$s9SectionIR6tuple1Si_S2iSdSbtvp" = {{.*}}constant <{ %TSi, %TSi, %TSi, {{.*}} }> <{ %TSi <{ {{i64|i32}} 1 }>, %TSi <{ {{i64|i32}} 2 }>, %TSi <{ {{i64|i32}} 3 }>, {{.*}} }>, section "mysection"
8091
// CHECK: @"$s9SectionIR6tuple2Si_SfSbtvp" = {{.*}}constant <{ %TSi, %TSf, %TSb }> <{ %TSi <{ {{i64|i32}} 42 }>, %TSf <{ float 0x40091EB860000000 }>, %TSb zeroinitializer }>, section "mysection"
8192
// CHECK: @"$s9SectionIR6tuple3Siyc_SSSictvp" = {{.*}}constant <{ %swift.function, %swift.function }> <{ %swift.function { ptr @"$s9SectionIR3fooSiyF{{.*}}", ptr null }, %swift.function { ptr @"$s9SectionIR3bar1xSSSi_tF{{.*}}", ptr null } }>, section "mysection"

‎test/ConstValues/SectionSyntactic.swift‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -121,6 +121,9 @@ enum E { case a }
121121

122122
// metatypes
123123
@section("mysection") let metatype1 = Int.self // ok
124+
@section("mysection") let metatype2: Any.Type = Int.self // ok
125+
@section("mysection") let metatype3: any (Hashable).Type = Int.self // ok
126+
@section("mysection") let metatype4: any (Hashable & Sendable).Type = Int.self // ok
124127

125128
// invalid metatype references
126129
@section("mysection") let invalidMetatype1 = Int.self.self

0 commit comments

Comments
 (0)