Merge pull request #79674 from eeckstein/simplify-open-existential-metatype

Optimizer: Rework peephole optimizations to replace existential (archetypes) with concrete types

Author: eeckstein

SwiftCompilerSources/Sources/AST/CMakeLists.txt

@@ -12,6 +12,7 @@ add_swift_compiler_module(AST
   SOURCES
     Declarations.swift
     Conformance.swift
+    GenericSignature.swift
     Registration.swift
     SubstitutionMap.swift
     Type.swift)

SwiftCompilerSources/Sources/AST/GenericSignature.swift

@@ -0,0 +1,28 @@
+//===--- GenericSignature.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Basic
+import ASTBridging
+
+/// Describes the generic signature of a particular declaration, including both the generic type
+/// parameters and the requirements placed on those generic parameters.
+public struct GenericSignature: CustomStringConvertible, NoReflectionChildren {
+  public let bridged: BridgedGenericSignature
+
+  public init(bridged: BridgedGenericSignature) {
+    self.bridged = bridged
+  }
+  
+  public var description: String {
+    return String(taking: bridged.getDebugDescription())
+  }
+}

SwiftCompilerSources/Sources/AST/SubstitutionMap.swift

@@ -18,7 +18,7 @@ import ASTBridging
 ///
 /// Substitution maps are primarily used when performing substitutions into any entity that
 /// can reference type parameters and conformances.
-public struct SubstitutionMap: CustomStringConvertible {
+public struct SubstitutionMap: CustomStringConvertible, NoReflectionChildren {
   public let bridged: BridgedSubstitutionMap
 
   public init(bridged: BridgedSubstitutionMap) {
@@ -28,6 +28,13 @@ public struct SubstitutionMap: CustomStringConvertible {
   public init() {
     self.bridged = BridgedSubstitutionMap()
   }
+  
+  public init(genericSignature: GenericSignature, replacementTypes: [Type]) {
+    let bridgedReplTypes = replacementTypes.map { $0.bridged }
+    self.bridged = bridgedReplTypes.withBridgedArrayRef {
+      return BridgedSubstitutionMap.get(genericSignature.bridged, $0)
+    }
+  }
 
   public var description: String {
     return String(taking: bridged.getDebugDescription())

SwiftCompilerSources/Sources/AST/Type.swift

@@ -15,9 +15,23 @@ import ASTBridging
 
 /// A Swift type.
 /// It is not necessarily canoncial, e.g. typealiases are not resolved.
-public struct Type: CustomStringConvertible, NoReflectionChildren {
+public struct Type: TypeProperties, CustomStringConvertible, NoReflectionChildren {
+  public enum TraitResult {
+    case isNot
+    case canBe
+    case `is`
+  }
+
+  public enum MetatypeRepresentation {
+    case thin
+    case thick
+    case objC
+  };
+
   public let bridged: BridgedASTType
 
+  public var type: Type { self }
+
   public init?(bridgedOrNil: BridgedASTType) {
     if bridgedOrNil.type == nil {
       return nil
@@ -30,47 +44,81 @@ public struct Type: CustomStringConvertible, NoReflectionChildren {
   }
 
   public var canonical: CanonicalType { CanonicalType(bridged: bridged.getCanonicalType()) }
-  public var description: String { String(taking: bridged.getDebugDescription()) }
 
-  public var hasTypeParameter: Bool { bridged.hasTypeParameter() }
-  public var isOpenedExistentialWithError: Bool { bridged.isOpenedExistentialWithError() }
-  public var isEscapable: Bool { bridged.isEscapable() }
-  public var isNoEscape: Bool { bridged.isNoEscape() }
-  public var isInteger: Bool { bridged.isInteger() }
+  public var instanceTypeOfMetatype: Type { Type(bridged: bridged.getInstanceTypeOfMetatype()) }
 
   public func subst(with substitutionMap: SubstitutionMap) -> Type {
     return Type(bridged: bridged.subst(substitutionMap.bridged))
   }
+
+  public func subst(type: Type, with targetType: Type) -> Type {
+    return Type(bridged: bridged.subst(type.bridged, targetType.bridged))
+  }
 }
 
 /// A Type that is statically known to be canonical.
 /// For example, typealiases are resolved.
-public struct CanonicalType: CustomStringConvertible, NoReflectionChildren {
-  public enum TraitResult {
-    case isNot
-    case canBe
-    case `is`
-  }
-
+public struct CanonicalType: TypeProperties, CustomStringConvertible, NoReflectionChildren {
   public let bridged: BridgedCanType
 
   public init(bridged: BridgedCanType) { self.bridged = bridged }
 
   public var type: Type { Type(bridged: bridged.getType()) }
 
-  public var description: String { type.description }
-
-  public var hasTypeParameter: Bool { type.hasTypeParameter }
-  public var isOpenedExistentialWithError: Bool { type.isOpenedExistentialWithError }
-  public var isEscapable: Bool { type.isEscapable }
-  public var isNoEscape: Bool { type.isNoEscape }
-  public var isInteger: Bool { type.isInteger }
-
+  public var instanceTypeOfMetatype: CanonicalType { type.instanceTypeOfMetatype.canonical }
+  
   public func subst(with substitutionMap: SubstitutionMap) -> CanonicalType {
     return type.subst(with: substitutionMap).canonical
   }
 
-  public var canBeClass: TraitResult { bridged.canBeClass().result }
+  public func subst(type: CanonicalType, with targetType: CanonicalType) -> CanonicalType {
+    return self.type.subst(type: type.type, with: targetType.type).canonical
+  }
+}
+
+/// Contains common properties of AST.Type and AST.CanonicalType
+public protocol TypeProperties {
+  var type: Type { get }
+}
+
+extension TypeProperties {
+  public var description: String { String(taking: type.bridged.getDebugDescription()) }
+
+  public var isLegalFormalType: Bool { type.bridged.isLegalFormalType() }
+  public var hasTypeParameter: Bool { type.bridged.hasTypeParameter() }
+  public var hasLocalArchetype: Bool { type.bridged.hasLocalArchetype() }
+  public var isExistentialArchetype: Bool { type.bridged.isExistentialArchetype() }
+  public var isExistentialArchetypeWithError: Bool { type.bridged.isExistentialArchetypeWithError() }
+  public var isExistential: Bool { type.bridged.isExistential() }
+  public var isEscapable: Bool { type.bridged.isEscapable() }
+  public var isNoEscape: Bool { type.bridged.isNoEscape() }
+  public var isInteger: Bool { type.bridged.isInteger() }
+  public var isMetatypeType: Bool { type.bridged.isMetatypeType() }
+  public var isExistentialMetatypeType: Bool { type.bridged.isExistentialMetatypeType() }
+  public var representationOfMetatype: AST.`Type`.MetatypeRepresentation {
+    type.bridged.getRepresentationOfMetatype().representation
+  }
+  public var invocationGenericSignatureOfFunctionType: GenericSignature {
+    GenericSignature(bridged: type.bridged.getInvocationGenericSignatureOfFunctionType())
+  }
+
+  public var canBeClass: Type.TraitResult { type.bridged.canBeClass().result }
+
+  public var anyNominal: NominalTypeDecl? { type.bridged.getAnyNominal().getAs(NominalTypeDecl.self) }
+
+  /// Performas a global conformance lookup for this type for `protocol`.
+  /// It checks conditional requirements.
+  ///
+  /// This type must be a contextualized type. It must not contain type parameters.
+  ///
+  /// The resulting conformance reference does not include "missing" conformances, which are synthesized for
+  /// some protocols as an error recovery mechanism.
+  ///
+  /// Returns an invalid conformance if the search failed, otherwise an
+  /// abstract, concrete or pack conformance, depending on the lookup type.
+  public func checkConformance(to protocol: ProtocolDecl) -> Conformance {
+    return Conformance(bridged: type.bridged.checkConformance(`protocol`.bridged))
+  }
 }
 
 public struct TypeArray : RandomAccessCollection, CustomReflectable {
@@ -93,8 +141,8 @@ public struct TypeArray : RandomAccessCollection, CustomReflectable {
   }
 }
 
-extension BridgedCanType.TraitResult {
-  var result: CanonicalType.TraitResult {
+extension BridgedASTType.TraitResult {
+  var result: Type.TraitResult {
     switch self {
     case .IsNot: return .isNot
     case .CanBe: return .canBe
@@ -104,3 +152,27 @@ extension BridgedCanType.TraitResult {
     }
   }
 }
+
+extension BridgedASTType.MetatypeRepresentation {
+  var representation: Type.MetatypeRepresentation {
+    switch self {
+    case .Thin:  return .thin
+    case .Thick: return .thick
+    case .ObjC:  return .objC
+    default:
+      fatalError("wrong type MetatypeRepresentation enum case")
+    }
+  }
+}
+
+extension Type: Equatable {
+  public static func ==(lhs: Type, rhs: Type) -> Bool { 
+    lhs.bridged.type == rhs.bridged.type
+  }
+}
+
+extension CanonicalType: Equatable {
+  public static func ==(lhs: CanonicalType, rhs: CanonicalType) -> Bool { 
+    lhs.type == rhs.type
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   SimplifyAllocRefDynamic.swift
+  SimplifyAllocStack.swift
   SimplifyApply.swift
   SimplifyBeginAndLoadBorrow.swift
   SimplifyBeginCOWMutation.swift
@@ -38,4 +39,5 @@ swift_compiler_sources(Optimizer
   SimplifyTuple.swift
   SimplifyTupleExtract.swift
   SimplifyUncheckedEnumData.swift
-  SimplifyValueToBridgeObject.swift)
+  SimplifyValueToBridgeObject.swift
+  SimplifyWitnessMethod.swift)