Merge pull request swiftlang#26542 from jckarter/opaque-type-metadata-peephole

IRGen: Peephole metadata requests for opaque types.

Author: jckarter

lib/AST/Type.cpp

@@ -2551,6 +2551,10 @@ bool ReplaceOpaqueTypesWithUnderlyingTypes::shouldPerformSubstitution(
  OpaqueTypeDecl *opaque, ModuleDecl *contextModule,
  ResilienceExpansion contextExpansion) {
  auto namingDecl = opaque->getNamingDecl();
+ 
+ // Don't allow replacement if the naming decl is dynamically replaceable.
+ if (namingDecl && namingDecl->isDynamic())
+ return false;
 
  // Allow replacement of opaque result types of inlineable function regardless
  // of resilience and in which context.

lib/IRGen/GenProto.cpp

@@ -2739,6 +2739,12 @@ llvm::Value *irgen::emitWitnessTableRef(IRGenFunction &IGF,
  assert(Lowering::TypeConverter::protocolRequiresWitnessTable(proto)
  && "protocol does not have witness tables?!");
 
+ // Look through any opaque types we're allowed to.
+ if (srcType->hasOpaqueArchetype()) {
+ std::tie(srcType, conformance) =
+ IGF.IGM.substOpaqueTypesWithUnderlyingTypes(srcType, conformance);
+ }
+ 
  // If we don't have concrete conformance information, the type must be
  // an archetype and the conformance must be via one of the protocol
  // requirements of the archetype. Look at what's locally bound.

lib/IRGen/GenReflection.cpp

@@ -176,6 +176,8 @@ IRGenModule::getTypeRef(Type type, GenericSignature *genericSig,
 
 std::pair<llvm::Constant *, unsigned>
 IRGenModule::getTypeRef(CanType type, MangledTypeRefRole role) {
+ type = substOpaqueTypesWithUnderlyingTypes(type);
+ 
  switch (role) {
  case MangledTypeRefRole::DefaultAssociatedTypeWitness:
  case MangledTypeRefRole::Metadata:
@@ -209,6 +211,9 @@ IRGenModule::emitWitnessTableRefString(CanType type,
  ProtocolConformanceRef conformance,
  GenericSignature *origGenericSig,
  bool shouldSetLowBit) {
+ std::tie(type, conformance)
+ = substOpaqueTypesWithUnderlyingTypes(type, conformance);
+ 
  auto origType = type;
  CanGenericSignature genericSig;
  SmallVector<GenericRequirement, 4> requirements;

lib/IRGen/GenType.cpp

@@ -1606,7 +1606,7 @@ const TypeInfo *TypeConverter::getTypeEntry(CanType canonicalTy) {
  return it->second;
  }
  }
- 
+
  // If the type is dependent, substitute it into our current context.
  auto contextTy = canonicalTy;
  if (contextTy->hasTypeParameter()) {

lib/IRGen/IRGenModule.h

@@ -820,6 +820,13 @@ class IRGenModule {
  }
 
  clang::CodeGen::CodeGenModule &getClangCGM() const;
+ 
+ CanType getRuntimeReifiedType(CanType type);
+ CanType substOpaqueTypesWithUnderlyingTypes(CanType type);
+ SILType substOpaqueTypesWithUnderlyingTypes(SILType type);
+ std::pair<CanType, ProtocolConformanceRef>
+ substOpaqueTypesWithUnderlyingTypes(CanType type,
+ ProtocolConformanceRef conformance);
 
  bool isResilient(NominalTypeDecl *decl, ResilienceExpansion expansion);
  bool hasResilientMetadata(ClassDecl *decl, ResilienceExpansion expansion);

lib/IRGen/IRGenSIL.cpp

@@ -857,7 +857,7 @@ class IRGenSILFunction :
  /// TODO: just make sure that we have a path to them that the debug info
  /// can follow.
  void bindArchetypes(swift::Type Ty) {
- auto runtimeTy = getRuntimeReifiedType(IGM, Ty->getCanonicalType());
+ auto runtimeTy = IGM.getRuntimeReifiedType(Ty->getCanonicalType());
  if (!IGM.IRGen.Opts.shouldOptimize() && runtimeTy->hasArchetype())
  runtimeTy.visit([&](CanType t) {
  if (auto archetype = dyn_cast<ArchetypeType>(t))

lib/IRGen/MetadataRequest.cpp

@@ -501,8 +501,9 @@ static bool isTypeErasedGenericClassType(CanType type) {
 }
 
 // Get the type that exists at runtime to represent a compile-time type.
-CanType
-irgen::getRuntimeReifiedType(IRGenModule &IGM, CanType type) {
+CanType IRGenModule::getRuntimeReifiedType(CanType type) {
+ // Leave type-erased ObjC generics with their generic arguments unbound, since
+ // the arguments do not exist at runtime.
  return CanType(type.transform([&](Type t) -> Type {
  if (isTypeErasedGenericClassType(CanType(t))) {
  return t->getAnyNominal()->getDeclaredType()->getCanonicalType();
@@ -511,6 +512,53 @@ irgen::getRuntimeReifiedType(IRGenModule &IGM, CanType type) {
  }));
 }
 
+CanType IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type) {
+ // Substitute away opaque types whose underlying types we're allowed to
+ // assume are constant.
+ if (type->hasOpaqueArchetype()) {
+ ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
+ ResilienceExpansion::Maximal);
+ type = type.subst(replacer, replacer,
+ SubstFlags::SubstituteOpaqueArchetypes)
+ ->getCanonicalType();
+ }
+
+ return type;
+}
+
+SILType IRGenModule::substOpaqueTypesWithUnderlyingTypes(SILType type) {
+ // Substitute away opaque types whose underlying types we're allowed to
+ // assume are constant.
+ if (type.getASTType()->hasOpaqueArchetype()) {
+ ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
+ ResilienceExpansion::Maximal);
+ type = type.subst(getSILModule(), replacer, replacer,
+ CanGenericSignature(),
+ /*substitute opaque*/ true);
+ }
+
+ return type;
+}
+
+std::pair<CanType, ProtocolConformanceRef>
+IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type,
+ ProtocolConformanceRef conformance) {
+ // Substitute away opaque types whose underlying types we're allowed to
+ // assume are constant.
+ if (type->hasOpaqueArchetype()) {
+ ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
+ ResilienceExpansion::Maximal);
+ conformance = conformance.subst(type, replacer, replacer,
+ SubstFlags::SubstituteOpaqueArchetypes);
+ type = type.subst(replacer, replacer,
+ SubstFlags::SubstituteOpaqueArchetypes)
+ ->getCanonicalType();
+ }
+
+ return std::make_pair(type, conformance);
+}
+
+
 /// Attempts to return a constant heap metadata reference for a
 /// class type. This is generally only valid for specific kinds of
 /// ObjC reference, like superclasses or category references.
@@ -2313,7 +2361,9 @@ llvm::Value *IRGenFunction::emitTypeMetadataRef(CanType type) {
 MetadataResponse
 IRGenFunction::emitTypeMetadataRef(CanType type,
  DynamicMetadataRequest request) {
- type = getRuntimeReifiedType(IGM, type);
+ type = IGM.getRuntimeReifiedType(type);
+ // Look through any opaque types we're allowed to.
+ type = IGM.substOpaqueTypesWithUnderlyingTypes(type);
 
  if (type->hasArchetype() ||
  isTypeMetadataAccessTrivial(IGM, type)) {
@@ -2328,7 +2378,7 @@ IRGenFunction::emitTypeMetadataRef(CanType type,
 /// for the given non-dependent type.
 llvm::Function *irgen::getOrCreateTypeMetadataAccessFunction(IRGenModule &IGM,
  CanType type) {
- type = getRuntimeReifiedType(IGM, type);
+ type = IGM.getRuntimeReifiedType(type);
 
  assert(!type->hasArchetype() &&
  "cannot create global function to return dependent type metadata");

lib/IRGen/MetadataRequest.h

@@ -583,10 +583,6 @@ ConstantReference tryEmitConstantTypeMetadataRef(IRGenModule &IGM,
  CanType type,
  SymbolReferenceKind refKind);
 
-/// Get the type as it exists in Swift's runtime type system, removing any
-/// erased generic parameters.
-CanType getRuntimeReifiedType(IRGenModule &IGM, CanType type);
-
 /// Emit a reference to a compile-time constant piece of heap metadata, or
 /// return a null pointer if the type's heap metadata cannot be represented
 /// by a constant.

test/IRGen/Inputs/opaque_result_type_metadata_external.swift

@@ -0,0 +1,17 @@
+
+public protocol P {
+ static func stat()
+}
+
+extension Int: P {
+ public static func stat() {}
+}
+
+public func external_opaque() -> some P {
+ return 0
+}
+
+@inlinable
+public func external_inlinable() -> some P {
+ return 0
+}

test/IRGen/lazy_opaque_result_type.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -disable-availability-checking -Xllvm -sil-disable-pass=OpaqueArchetypeSpecializer -parse-as-library -module-name=test -O -primary-file %s -emit-ir > %t.ll
+// RUN: %target-swift-frontend -enable-implicit-dynamic -disable-availability-checking -Xllvm -sil-disable-pass=OpaqueArchetypeSpecializer -parse-as-library -module-name=test -O -primary-file %s -emit-ir > %t.ll
 // RUN: %FileCheck %s < %t.ll
 
 protocol P { }