SIL: add CanonicalType.canBeClass

And move the implementation of `SIL.Type.canBeClass` to the AST Type. The SIL Type just calls the AST Type implementation.
Also rename `SIL.Type.canonicalASTType` -> `SIL.Type.astType`.

Author: eeckstein

SwiftCompilerSources/Sources/AST/Type.swift

@@ -46,6 +46,12 @@ public struct Type: CustomStringConvertible, NoReflectionChildren {
 /// 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 let bridged: BridgedCanType
 
   public init(bridged: BridgedCanType) { self.bridged = bridged }
@@ -63,6 +69,8 @@ public struct CanonicalType: CustomStringConvertible, NoReflectionChildren {
   public func subst(with substitutionMap: SubstitutionMap) -> CanonicalType {
     return type.subst(with: substitutionMap).canonical
   }
+
+  public var canBeClass: TraitResult { bridged.canBeClass().result }
 }
 
 public struct TypeArray : RandomAccessCollection, CustomReflectable {
@@ -84,3 +92,15 @@ public struct TypeArray : RandomAccessCollection, CustomReflectable {
     return Mirror(self, children: c)
   }
 }
+
+extension BridgedCanType.TraitResult {
+  var result: CanonicalType.TraitResult {
+    switch self {
+    case .IsNot: return .isNot
+    case .CanBe: return .canBe
+    case .Is:    return .is
+    default:
+      fatalError("wrong type TraitResult enum case")
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -129,21 +129,16 @@ private extension BuiltinInst {
   }
 
   func optimizeCanBeClass(_ context: SimplifyContext) {
-    guard let ty = substitutionMap.replacementTypes[0].canonical.silType else {
-      return
-    }
     let literal: IntegerLiteralInst
-    switch ty.canBeClass {
-    case .IsNot:
+    switch substitutionMap.replacementType.canonical.canBeClass {
+    case .isNot:
       let builder = Builder(before: self, context)
       literal = builder.createIntegerLiteral(0,  type: type)
-    case .Is:
+    case .is:
       let builder = Builder(before: self, context)
       literal = builder.createIntegerLiteral(1,  type: type)
-    case .CanBe:
+    case .canBe:
       return
-    default:
-      fatalError()
     }
     self.replace(with: literal, context)
   }

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -27,7 +27,7 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var addressType: Type { bridged.getAddressType().type }
   public var objectType: Type { bridged.getObjectType().type }
 
-  public var canonicalASTType: CanonicalType { CanonicalType(bridged: bridged.getCanType()) }
+  public var astType: CanonicalType { CanonicalType(bridged: bridged.getCanType()) }
 
   public func isTrivial(in function: Function) -> Bool {
     return bridged.isTrivial(function.bridged)
@@ -68,7 +68,7 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var isThickFunction: Bool { bridged.isThickFunction() }
   public var isAsyncFunction: Bool { bridged.isAsyncFunction() }
 
-  public var canBeClass: BridgedType.TraitResult { bridged.canBeClass() }
+  public var canBeClass: CanonicalType.TraitResult { astType.canBeClass }
 
   public var isMoveOnly: Bool { bridged.isMoveOnly() }
 

include/swift/AST/ASTBridging.h

@@ -2288,9 +2288,16 @@ class BridgedCanType {
   swift::TypeBase * _Nullable type;
 
 public:
+  enum class TraitResult {
+    IsNot,
+    CanBe,
+    Is
+  };
+
   BRIDGED_INLINE BridgedCanType(swift::CanType ty);
   BRIDGED_INLINE swift::CanType unbridged() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType getType() const;
+  BRIDGED_INLINE TraitResult canBeClass() const;
 };
 
 struct BridgedASTTypeArray {

include/swift/AST/ASTBridgingImpl.h

@@ -327,6 +327,10 @@ BridgedASTType BridgedASTType::subst(BridgedSubstitutionMap substMap) const {
 // MARK: BridgedCanType
 //===----------------------------------------------------------------------===//
 
+static_assert((int)BridgedCanType::TraitResult::IsNot == (int)swift::TypeTraitResult::IsNot);
+static_assert((int)BridgedCanType::TraitResult::CanBe == (int)swift::TypeTraitResult::CanBe);
+static_assert((int)BridgedCanType::TraitResult::Is == (int)swift::TypeTraitResult::Is);
+
 BridgedCanType::BridgedCanType(swift::CanType ty) : type(ty.getPointer()) {
 }
 
@@ -338,6 +342,10 @@ BridgedASTType BridgedCanType::getType() const {
   return {type};
 }
 
+BridgedCanType::TraitResult BridgedCanType::canBeClass() const {
+  return (TraitResult)unbridged()->canBeClass();
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedASTTypeArray
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILBridging.h

@@ -228,12 +228,6 @@ struct BridgedType {
     ObjC
   };
 
-  enum class TraitResult {
-    IsNot,
-    CanBe,
-    Is
-  };
-
   struct EnumElementIterator {
     uint64_t storage[4];
 
@@ -277,7 +271,6 @@ struct BridgedType {
   BRIDGED_INLINE bool isAsyncFunction() const;
   BRIDGED_INLINE bool isVoid() const;
   BRIDGED_INLINE bool isEmpty(BridgedFunction f) const;
-  BRIDGED_INLINE TraitResult canBeClass() const;
   BRIDGED_INLINE bool isMoveOnly() const;
   BRIDGED_INLINE bool isEscapable(BridgedFunction f) const;
   BRIDGED_INLINE bool isOrContainsObjectiveCClass() const;

include/swift/SIL/SILBridgingImpl.h

@@ -421,10 +421,6 @@ bool BridgedType::isEmpty(BridgedFunction f) const {
   return unbridged().isEmpty(*f.getFunction());
 }
 
-BridgedType::TraitResult BridgedType::canBeClass() const {
-  return (TraitResult)unbridged().canBeClass();
-}
-
 bool BridgedType::isMoveOnly() const {
   return unbridged().isMoveOnly();
 }

lib/SIL/Utils/SILBridging.cpp

@@ -170,11 +170,6 @@ static_assert((int)BridgedType::MetatypeRepresentation::Thin == (int)swift::Meta
 static_assert((int)BridgedType::MetatypeRepresentation::Thick == (int)swift::MetatypeRepresentation::Thick);
 static_assert((int)BridgedType::MetatypeRepresentation::ObjC == (int)swift::MetatypeRepresentation::ObjC);
 
-static_assert((int)BridgedType::TraitResult::IsNot == (int)swift::TypeTraitResult::IsNot);
-static_assert((int)BridgedType::TraitResult::CanBe == (int)swift::TypeTraitResult::CanBe);
-static_assert((int)BridgedType::TraitResult::Is == (int)swift::TypeTraitResult::Is);
-
-
 //===----------------------------------------------------------------------===//
 //                                SILFunction
 //===----------------------------------------------------------------------===//