AST/SIL: Refactor and simplify AST.Type, AST.CanonicalType and SIL.Type

* let `SIL.Type` conform to `TypeProperties` to share the implementation of common type properties between the AST types and `SIL.Type`
* call references to an `AST.Type` `rawType` (instead of just `type`)
* remove unneeded stuff
* add comments

Author: eeckstein

SwiftCompilerSources/Sources/AST/Type.swift

@@ -30,7 +30,8 @@ public struct Type: TypeProperties, CustomStringConvertible, NoReflectionChildre
 
   public let bridged: BridgedASTType
 
-  public var type: Type { self }
+  // Needed to conform to TypeProperties
+  public var rawType: Type { self }
 
   public init?(bridgedOrNil: BridgedASTType) {
     if bridgedOrNil.type == nil {
@@ -47,6 +48,17 @@ public struct Type: TypeProperties, CustomStringConvertible, NoReflectionChildre
 
   public var instanceTypeOfMetatype: Type { Type(bridged: bridged.getInstanceTypeOfMetatype()) }
 
+  public var superClassType: Type? {
+    precondition(isClass)
+    let bridgedSuperClassTy = bridged.getSuperClassType()
+    if bridgedSuperClassTy.type != nil {
+      return Type(bridged: bridgedSuperClassTy)
+    }
+    return nil
+  }
+
+  public var builtinVectorElementType: Type { Type(bridged: bridged.getBuiltinVectorElementType()) }
+
   public func subst(with substitutionMap: SubstitutionMap) -> Type {
     return Type(bridged: bridged.subst(substitutionMap.bridged))
   }
@@ -63,49 +75,123 @@ public struct CanonicalType: TypeProperties, CustomStringConvertible, NoReflecti
 
   public init(bridged: BridgedCanType) { self.bridged = bridged }
 
-  public var type: Type { Type(bridged: bridged.getType()) }
+  public var rawType: Type { Type(bridged: bridged.getRawType()) }
+
+  public var instanceTypeOfMetatype: CanonicalType { rawType.instanceTypeOfMetatype.canonical }
+
+  public var superClassType: CanonicalType? { rawType.superClassType?.canonical }
+
+  public var builtinVectorElementType: CanonicalType { rawType.builtinVectorElementType.canonical }
 
-  public var instanceTypeOfMetatype: CanonicalType { type.instanceTypeOfMetatype.canonical }
-  
   public func subst(with substitutionMap: SubstitutionMap) -> CanonicalType {
-    return type.subst(with: substitutionMap).canonical
+    return rawType.subst(with: substitutionMap).canonical
   }
 
   public func subst(type: CanonicalType, with targetType: CanonicalType) -> CanonicalType {
-    return self.type.subst(type: type.type, with: targetType.type).canonical
+    return self.rawType.subst(type: type.rawType, with: targetType.rawType).canonical
   }
 }
 
-/// Contains common properties of AST.Type and AST.CanonicalType
+/// Implements the common members of `AST.Type`, `AST.CanonicalType` and `SIL.Type`.
 public protocol TypeProperties {
-  var type: Type { get }
+  var rawType: 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 isOptional: Bool { type.bridged.isOptional() }
-  public var isMetatypeType: Bool { type.bridged.isMetatypeType() }
-  public var isExistentialMetatypeType: Bool { type.bridged.isExistentialMetatypeType() }
+  public var description: String { String(taking: rawType.bridged.getDebugDescription()) }
+
+  //===--------------------------------------------------------------------===//
+  //                      Checks for different kinds of types
+  //===--------------------------------------------------------------------===//
+
+  public var isBuiltinInteger: Bool { rawType.bridged.isBuiltinInteger() }
+
+  public func isBuiltinInteger(withFixedWidth width: Int) -> Bool {
+    rawType.bridged.isBuiltinFixedWidthInteger(width)
+  }
+
+  public var isBuiltinFloat: Bool { rawType.bridged.isBuiltinFloat() }
+  public var isBuiltinVector: Bool { rawType.bridged.isBuiltinVector() }
+
+  public var isClass: Bool {
+    if let nominal = nominal, nominal is ClassDecl {
+      return true
+    }
+    return false
+  }
+
+  public var isStruct: Bool {
+    if let nominal = nominal, nominal is StructDecl {
+      return true
+    }
+    return false
+  }
+
+  public var isEnum: Bool  {
+    if let nominal = nominal, nominal is EnumDecl {
+      return true
+    }
+    return false
+  }
+
+  public var isTuple: Bool { rawType.bridged.isTuple() }
+  public var isFunction: Bool { rawType.bridged.isFunction() }
+  public var isExistentialArchetype: Bool { rawType.bridged.isExistentialArchetype() }
+  public var isExistentialArchetypeWithError: Bool { rawType.bridged.isExistentialArchetypeWithError() }
+  public var isExistential: Bool { rawType.bridged.isExistential() }
+  public var isClassExistential: Bool { rawType.bridged.isClassExistential() }
+  public var isUnownedStorageType: Bool { return rawType.bridged.isUnownedStorageType() }
+  public var isMetatype: Bool { rawType.bridged.isMetatypeType() }
+  public var isExistentialMetatype: Bool { rawType.bridged.isExistentialMetatypeType() }
+  public var isDynamicSelf: Bool { rawType.bridged.isDynamicSelf()}
+
+  /// True if this is the type which represents an integer literal used in a type position.
+  /// For example `N` in `struct T<let N: Int> {}`
+  public var isInteger: Bool { rawType.bridged.isInteger() }
+
+  public var canBeClass: Type.TraitResult { rawType.bridged.canBeClass().result }
+
+  /// True if this the nominal type `Swift.Optional`.
+  public var isOptional: Bool { rawType.bridged.isOptional() }
+
+  /// True if this type is a value type (struct/enum) that defines a `deinit`.
+  public var isValueTypeWithDeinit: Bool {
+    if let nominal = nominal, nominal.valueTypeDestructor != nil {
+      return true
+    }
+    return false
+  }
+
+  //===--------------------------------------------------------------------===//
+  //                             Type properties
+  //===--------------------------------------------------------------------===//
+
+  public var isLegalFormalType: Bool { rawType.bridged.isLegalFormalType() }
+  public var hasArchetype: Bool { rawType.bridged.hasArchetype() }
+  public var hasTypeParameter: Bool { rawType.bridged.hasTypeParameter() }
+  public var hasLocalArchetype: Bool { rawType.bridged.hasLocalArchetype() }
+  public var isEscapable: Bool { rawType.bridged.isEscapable() }
+  public var isNoEscape: Bool { rawType.bridged.isNoEscape() }
+
   public var representationOfMetatype: AST.`Type`.MetatypeRepresentation {
-    type.bridged.getRepresentationOfMetatype().representation
+    rawType.bridged.getRepresentationOfMetatype().representation
   }
-  public var invocationGenericSignatureOfFunctionType: GenericSignature {
-    GenericSignature(bridged: type.bridged.getInvocationGenericSignatureOfFunctionType())
+
+  /// Assumes this is a nominal type. Returns a substitution map that sends each
+  /// generic parameter of the declaration's generic signature to the corresponding
+  /// generic argument of this nominal type.
+  ///
+  /// Eg: Array<Int> ---> { Element := Int }
+  public var contextSubstitutionMap: SubstitutionMap {
+    SubstitutionMap(bridged: rawType.bridged.getContextSubstitutionMap())
   }
 
-  public var canBeClass: Type.TraitResult { type.bridged.canBeClass().result }
+  // True if this type has generic parameters or it is in a context (e.g. an outer type) which has generic parameters.
+  public var isGenericAtAnyLevel: Bool { rawType.bridged.isGenericAtAnyLevel() }
 
-  public var anyNominal: NominalTypeDecl? { type.bridged.getAnyNominal().getAs(NominalTypeDecl.self) }
+  public var nominal: NominalTypeDecl? {
+    rawType.bridged.getNominalOrBoundGenericNominal().getAs(NominalTypeDecl.self)
+  }
 
   /// Performas a global conformance lookup for this type for `protocol`.
   /// It checks conditional requirements.
@@ -118,7 +204,7 @@ extension TypeProperties {
   /// 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))
+    return Conformance(bridged: rawType.bridged.checkConformance(`protocol`.bridged))
   }
 }
 
@@ -174,6 +260,6 @@ extension Type: Equatable {
 
 extension CanonicalType: Equatable {
   public static func ==(lhs: CanonicalType, rhs: CanonicalType) -> Bool { 
-    lhs.type == rhs.type
+    lhs.rawType == rhs.rawType
   }
 }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift

@@ -1127,7 +1127,7 @@ private extension PartialApplyInst {
     if self.numArguments == 1, 
        let fun = self.referencedFunction,
        fun.thunkKind == .reabstractionThunk || fun.thunkKind == .thunk,
-       self.arguments[0].type.isFunction,
+       self.arguments[0].type.isLoweredFunction,
        self.arguments[0].type.isReferenceCounted(in: self.parentFunction) || self.callee.type.isThickFunction
     {
       return true

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyAllocStack.swift

@@ -179,7 +179,7 @@ private extension AllocStackInst {
   ///   use %3
   /// ```
   func optimizeExistential(_ context: SimplifyContext) -> Bool {
-    guard type.astType.isExistential || type.astType.isExistentialArchetype,
+    guard type.isExistential || type.isExistentialArchetype,
           let concreteFormalType = getConcreteTypeOfExistential()
     else {
       return false
@@ -266,7 +266,7 @@ private extension AllocStackInst {
     }
     let concreteType: CanonicalType
     if let initExistential {
-      assert(self.type.astType.isExistential)
+      assert(self.type.isExistential)
       if let cft = initExistential.concreteTypeOfDependentExistentialArchetype {
         // Case 1: We will replace the alloc_stack of an existential with the concrete type.
         //         `alloc_stack $any P` -> `alloc_stack $ConcreteType`
@@ -281,9 +281,9 @@ private extension AllocStackInst {
         }
         // Case 2: We will replace the alloc_stack of an existential with the existential archetype.
         //         `alloc_stack $any P` -> `alloc_stack $@opened("...")`
-        concreteType = initExistential.type.astType
+        concreteType = initExistential.type.canonicalType
       }
-    } else if self.type.astType.isExistentialArchetype, let cft = self.concreteTypeOfDependentExistentialArchetype {
+    } else if self.type.isExistentialArchetype, let cft = self.concreteTypeOfDependentExistentialArchetype {
       // Case 3: We will replace the alloc_stack of an existential archetype with the concrete type:
       //         `alloc_stack $@opened("...")` -> `alloc_stack $ConcreteType`
       concreteType = cft

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyApply.swift

@@ -143,22 +143,22 @@ private extension FullApplySite {
     // Note that an opened existential value is address only, so it cannot be a direct result anyway
     // (but it can be once we have opaque values).
     // Also don't support things like direct `Array<@opened("...")>` return values.
-    if let singleDirectResult, singleDirectResult.type.astType.hasLocalArchetype {
+    if let singleDirectResult, singleDirectResult.type.hasLocalArchetype {
       return false
     }
-    if let singleDirectErrorResult, singleDirectErrorResult.type.astType.hasLocalArchetype {
+    if let singleDirectErrorResult, singleDirectErrorResult.type.hasLocalArchetype {
       return false
     }
 
     return arguments.allSatisfy { value in
-      let astTy = value.type.astType
+      let type = value.type
       // Allow three cases:
              // case 1. the argument _is_ the existential archetype
-      return astTy.isExistentialArchetype ||
+      return type.isExistentialArchetype ||
              // case 2. the argument _is_ a metatype of the existential archetype
-             (astTy.isMetatypeType && astTy.instanceTypeOfMetatype.isExistentialArchetype) ||
+             (type.isMetatype && type.canonicalType.instanceTypeOfMetatype.isExistentialArchetype) ||
              // case 3. the argument has nothing to do with the existential archetype (or any other local archetype)
-             !astTy.hasLocalArchetype
+             !type.hasLocalArchetype
     }
   }
 
@@ -167,19 +167,18 @@ private extension FullApplySite {
     _ context: SimplifyContext
   ) -> [Value] {
     let newArgs = arguments.map { (arg) -> Value in
-      let argTy = arg.type.astType
-      if argTy.isExistentialArchetype {
+      if arg.type.isExistentialArchetype {
         // case 1. the argument _is_ the existential archetype:
         //         just insert an address cast to satisfy type equivalence.
         let builder = Builder(before: self, context)
         let concreteSILType = concreteType.loweredType(in: self.parentFunction)
         return builder.createUncheckedAddrCast(from: arg, to: concreteSILType.addressType)
       }
-      if argTy.isMetatypeType, argTy.instanceTypeOfMetatype.isExistentialArchetype {
+      if arg.type.isMetatype, arg.type.canonicalType.instanceTypeOfMetatype.isExistentialArchetype {
         // case 2. the argument _is_ a metatype of the existential archetype:
         //         re-create the metatype with the concrete type.
         let builder = Builder(before: self, context)
-        return builder.createMetatype(ofInstanceType: concreteType, representation: argTy.representationOfMetatype)
+        return builder.createMetatype(ofInstanceType: concreteType, representation: arg.type.representationOfMetatype)
       }
       // case 3. the argument has nothing to do with the existential archetype (or any other local archetype)
       return arg
@@ -194,9 +193,9 @@ private extension FullApplySite {
     let openedArcheType = substitutionMap.replacementTypes.first(where: { $0.isExistentialArchetype })!
 
     let newReplacementTypes = substitutionMap.replacementTypes.map {
-      return $0 == openedArcheType ? concreteType.type : $0
+      return $0 == openedArcheType ? concreteType.rawType : $0
     }
-    let genSig = callee.type.astType.invocationGenericSignatureOfFunctionType
+    let genSig = callee.type.invocationGenericSignatureOfFunction
     return SubstitutionMap(genericSignature: genSig, replacementTypes: newReplacementTypes)
   }
 }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -193,12 +193,12 @@ private extension BuiltinInst {
       return
     }
 
-    guard type.astType.representationOfMetatype == .thick else {
+    guard type.representationOfMetatype == .thick else {
       return
     }
 
     let builder = Builder(before: self, context)
-    let newMetatype = builder.createMetatype(ofInstanceType: type.astType.instanceTypeOfMetatype,
+    let newMetatype = builder.createMetatype(ofInstanceType: type.canonicalType.instanceTypeOfMetatype,
                                              representation: .thin)
     operands[argument].set(to: newMetatype, context)
   }
@@ -271,11 +271,11 @@ private func typesOfValuesAreEqual(_ lhs: Value, _ rhs: Value, in function: Func
 
   let lhsMetatype = lhsExistential.metatype.type
   let rhsMetatype = rhsExistential.metatype.type
-  if lhsMetatype.isDynamicSelfMetatype != rhsMetatype.isDynamicSelfMetatype {
-    return nil
-  }
   let lhsTy = lhsMetatype.loweredInstanceTypeOfMetatype(in: function)
   let rhsTy = rhsMetatype.loweredInstanceTypeOfMetatype(in: function)
+  if lhsTy.isDynamicSelf != rhsTy.isDynamicSelf {
+    return nil
+  }
 
   // Do we know the exact types? This is not the case e.g. if a type is passed as metatype
   // to the function.

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyCheckedCast.swift

@@ -70,15 +70,12 @@ private extension UnconditionalCheckedCastInst {
   // Note that init_existential_metatype is better than unconditional_checked_cast because it does not need
   // to do any runtime casting.
   func tryOptimizeCastToExistentialMetatype(_ context: SimplifyContext) {
-    guard targetFormalType.isExistentialMetatypeType,
-          sourceFormalType.isMetatypeType,
-          !sourceFormalType.isExistentialMetatypeType
-    else {
+    guard targetFormalType.isExistentialMetatype, sourceFormalType.isMetatype else {
       return
     }
 
     let instanceTy = targetFormalType.instanceTypeOfMetatype
-    guard let nominal = instanceTy.anyNominal,
+    guard let nominal = instanceTy.nominal,
           let proto = nominal as? ProtocolDecl
     else {
       return

SwiftCompilerSources/Sources/Optimizer/Utilities/FunctionSignatureTransforms.swift

@@ -148,7 +148,7 @@ private func removeMetatypArguments(in specializedFunction: Function, _ context:
     if funcArg.type.isRemovableMetatype(in: specializedFunction) {
       // Rematerialize the metatype value in the entry block.
       let builder = Builder(atBeginOf: entryBlock, context)
-      let instanceType = funcArg.type.astType.instanceTypeOfMetatype
+      let instanceType = funcArg.type.canonicalType.instanceTypeOfMetatype
       let metatype = builder.createMetatype(ofInstanceType: instanceType, representation: .thick)
       funcArg.uses.replaceAll(with: metatype, context)
       entryBlock.eraseArgument(at: funcArgIdx, context)
@@ -232,7 +232,7 @@ private func replace(apply: FullApplySite, to specializedCallee: Function, _ con
 private extension Type {
   func isRemovableMetatype(in function: Function) -> Bool {
     if isMetatype {
-      if astType.representationOfMetatype == .thick {
+      if representationOfMetatype == .thick {
         let instanceTy = loweredInstanceTypeOfMetatype(in: function)
         // For structs and enums we know the metatype statically.
         return instanceTy.isStruct || instanceTy.isEnum

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -145,7 +145,7 @@ func specializeWitnessTable(forConformance conformance: Conformance,
       let substType = witness.subst(with: conformance.specializedSubstitutions)
       return .associatedType(requirement: requirement, witness: substType)
     case .associatedConformance(let requirement, let proto, _):
-      let concreteAssociateConf = conformance.getAssociatedConformance(ofAssociatedType: requirement.type, to: proto)
+      let concreteAssociateConf = conformance.getAssociatedConformance(ofAssociatedType: requirement.rawType, to: proto)
       if concreteAssociateConf.isSpecialized {
         specializeWitnessTable(forConformance: concreteAssociateConf,
                                errorLocation: errorLocation,

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -478,7 +478,7 @@ extension Instruction {
        let iemt = oemt.operand.value as? InitExistentialMetatypeInst,
        let mt = iemt.metatype as? MetatypeInst
     {
-      return mt.type.astType.instanceTypeOfMetatype
+      return mt.type.canonicalType.instanceTypeOfMetatype
     }
     // TODO: also handle open_existential_addr and open_existential_ref.
     // Those cases are currently handled in SILCombine's `propagateConcreteTypeOfInitExistential`.