Swift AST: add some APIs to Type and CanonicalType

Author: eeckstein

SwiftCompilerSources/Sources/AST/Type.swift

@@ -33,14 +33,34 @@ public struct Type: CustomStringConvertible, NoReflectionChildren {
   public var description: String { String(taking: bridged.getDebugDescription()) }
 
   public var hasTypeParameter: Bool { bridged.hasTypeParameter() }
+  public var hasOpenedExistential: Bool { bridged.hasOpenedExistential() }
   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 isMetatypeType: Bool { bridged.isMetatypeType() }
+  public var isExistentialMetatypeType: Bool { bridged.isExistentialMetatypeType() }
 
+  public var anyNominal: NominalTypeDecl? { bridged.getAnyNominal().getAs(NominalTypeDecl.self) }
+  public var instanceTypeOfMetatype: Type { Type(bridged: bridged.getInstanceTypeOfMetatype()) }
+  
   public func subst(with substitutionMap: SubstitutionMap) -> Type {
     return Type(bridged: bridged.subst(substitutionMap.bridged))
   }
+  
+  /// 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: bridged.checkConformance(`protocol`.bridged))
+  }
 }
 
 /// A Type that is statically known to be canonical.
@@ -61,15 +81,26 @@ public struct CanonicalType: CustomStringConvertible, NoReflectionChildren {
   public var description: String { type.description }
 
   public var hasTypeParameter: Bool { type.hasTypeParameter }
+  public var hasOpenedExistential: Bool { type.hasOpenedExistential }
   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 isMetatypeType: Bool { type.isMetatypeType }
+  public var isExistentialMetatypeType: Bool { type.isExistentialMetatypeType }
 
+  public var anyNominal: NominalTypeDecl? { type.anyNominal }
+  public var instanceTypeOfMetatype: CanonicalType { type.instanceTypeOfMetatype.canonical }
+  
   public func subst(with substitutionMap: SubstitutionMap) -> CanonicalType {
     return type.subst(with: substitutionMap).canonical
   }
 
+  // See `type.checkConformance` 
+  public func checkConformance(to proto: ProtocolDecl) -> Conformance {
+    return type.checkConformance(to: proto)
+  }
+  
   public var canBeClass: TraitResult { bridged.canBeClass().result }
 }
 
@@ -104,3 +135,15 @@ extension BridgedCanType.TraitResult {
     }
   }
 }
+
+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
+  }
+}

include/swift/AST/ASTBridging.h

@@ -75,6 +75,7 @@ struct BridgedASTType;
 class BridgedCanType;
 class BridgedASTContext;
 struct BridgedSubstitutionMap;
+struct BridgedConformance;
 class BridgedParameterList;
 enum BridgedPlatformKind : size_t;
 
@@ -2989,11 +2990,17 @@ struct BridgedASTType {
   BRIDGED_INLINE BridgedOwnedString getDebugDescription() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType getCanonicalType() const;
   BRIDGED_INLINE bool hasTypeParameter() const;
+  BRIDGED_INLINE bool hasOpenedExistential() const;
   BRIDGED_INLINE bool isOpenedExistentialWithError() const;
   BRIDGED_INLINE bool isEscapable() const;
   BRIDGED_INLINE bool isNoEscape() const;
   BRIDGED_INLINE bool isInteger() const;
+  BRIDGED_INLINE bool isMetatypeType() const;
+  BRIDGED_INLINE bool isExistentialMetatypeType() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedDeclObj getAnyNominal() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType getInstanceTypeOfMetatype() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType subst(BridgedSubstitutionMap substMap) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformance checkConformance(BridgedDeclObj proto) const;  
 };
 
 class BridgedCanType {

include/swift/AST/ASTBridgingImpl.h

@@ -16,6 +16,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ArgumentList.h"
 #include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/ConformanceLookup.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/IfConfigClauseRangeInfo.h"
@@ -400,6 +401,10 @@ bool BridgedASTType::hasTypeParameter() const {
   return unbridged()->hasTypeParameter();
 }
 
+bool BridgedASTType::hasOpenedExistential() const {
+  return unbridged()->hasOpenedExistential();
+}
+
 bool BridgedASTType::isOpenedExistentialWithError() const {
   return unbridged()->isOpenedExistentialWithError();
 }
@@ -416,10 +421,30 @@ bool BridgedASTType::isInteger() const {
   return unbridged()->is<swift::IntegerType>();
 }
 
+bool BridgedASTType::isMetatypeType() const {
+  return unbridged()->is<swift::AnyMetatypeType>();
+}
+
+bool BridgedASTType::isExistentialMetatypeType() const {
+  return unbridged()->is<swift::ExistentialMetatypeType>();
+}
+
+OptionalBridgedDeclObj BridgedASTType::getAnyNominal() const {
+  return {unbridged()->getAnyNominal()};
+}
+
+BridgedASTType BridgedASTType::getInstanceTypeOfMetatype() const {
+  return {unbridged()->getAs<swift::AnyMetatypeType>()->getInstanceType().getPointer()};
+}
+
 BridgedASTType BridgedASTType::subst(BridgedSubstitutionMap substMap) const {
   return {unbridged().subst(substMap.unbridged()).getPointer()};
 }
 
+BridgedConformance BridgedASTType::checkConformance(BridgedDeclObj proto) const {
+  return swift::checkConformance(unbridged(), proto.getAs<swift::ProtocolDecl>(), /*allowMissing=*/ false);
+}  
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedCanType
 //===----------------------------------------------------------------------===//