Swift Bridging: remove BridgedType and directly use the C++ SILType instead

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -14,38 +14,40 @@ import Basic
 import SILBridging
 
 public struct Type : CustomStringConvertible, NoReflectionChildren {
-  public let bridged: BridgedType
+  public let bridged: swift.SILType
 
-  public var isAddress: Bool { SILType_isAddress(bridged) != 0 }
+  public var isAddress: Bool { bridged.isAddress() }
   public var isObject: Bool { !isAddress }
 
   public func isTrivial(in function: Function) -> Bool {
-    return SILType_isTrivial(bridged, function.bridged) != 0
+    return bridged.isTrivial(function.bridged.getFunction())
   }
 
   /// Returns true if the type is a trivial type and is and does not contain a Builtin.RawPointer.
   public func isTrivialNonPointer(in function: Function) -> Bool {
-    return SILType_isNonTrivialOrContainsRawPointer(bridged, function.bridged) == 0
+    return !bridged.isNonTrivialOrContainsRawPointer(function.bridged.getFunction())
   }
 
   public func isReferenceCounted(in function: Function) -> Bool {
-    return SILType_isReferenceCounted(bridged, function.bridged) != 0
+    return bridged.isReferenceCounted(function.bridged.getFunction())
   }
 
-  public var hasArchetype: Bool { SILType_hasArchetype(bridged) }
+  public var hasArchetype: Bool { bridged.hasArchetype() }
 
-  public var isNominal: Bool { SILType_isNominal(bridged) != 0 }
-  public var isClass: Bool { SILType_isClass(bridged) != 0 }
-  public var isStruct: Bool { SILType_isStruct(bridged) != 0 }
-  public var isTuple: Bool { SILType_isTuple(bridged) != 0 }
-  public var isEnum: Bool { SILType_isEnum(bridged) != 0 }
-  public var isFunction: Bool { SILType_isFunction(bridged) }
-  public var isMetatype: Bool { SILType_isMetatype(bridged) }
+  public var isNominal: Bool { bridged.getNominalOrBoundGenericNominal() != nil }
+  public var isClass: Bool { bridged.getClassOrBoundGenericClass() != nil }
+  public var isStruct: Bool { bridged.getStructOrBoundGenericStruct() != nil }
+  public var isTuple: Bool { bridged.isTuple() }
+  public var isEnum: Bool { bridged.getEnumOrBoundGenericEnum() != nil }
+  public var isFunction: Bool { bridged.isFunction() }
+  public var isMetatype: Bool { bridged.isMetatype() }
 
   /// Can only be used if the type is in fact a nominal type (`isNominal` is true).
-  public var nominal: Decl { Decl(bridged: SILType_getNominal(bridged)) }
+  public var nominal: NominalTypeDecl {
+    NominalTypeDecl(bridged: BridgedNominalTypeDecl(decl: bridged.getNominalOrBoundGenericNominal()))
+  }
 
-  public var isOrContainsObjectiveCClass: Bool { SILType_isOrContainsObjectiveCClass(bridged) }
+  public var isOrContainsObjectiveCClass: Bool { bridged.isOrContainsObjectiveCClass() }
 
   public var tupleElements: TupleElementArray { TupleElementArray(type: self) }
 
@@ -54,28 +56,28 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   }
 
   public func instanceTypeOfMetatype(in function: Function) -> Type {
-    SILType_instanceTypeOfMetatype(bridged, function.bridged).type
+    bridged.getInstanceTypeOfMetatype(function.bridged.getFunction()).type
   }
 
-  public var isCalleeConsumedFunction: Bool { SILType_isCalleeConsumedFunction(bridged) }
+  public var isCalleeConsumedFunction: Bool { bridged.isCalleeConsumedFunction() }
 
-  public var isMarkedAsImmortal: Bool { SILType_isMarkedAsImmortal(bridged) }
+  public var isMarkedAsImmortal: Bool { bridged.isMarkedAsImmortal() }
 
   public func getIndexOfEnumCase(withName name: String) -> Int? {
     let idx = name._withStringRef {
-      SILType_getCaseIdxOfEnumType(bridged, $0)
+      bridged.getCaseIdxOfEnumType($0)
     }
     return idx >= 0 ? idx : nil
   }
 
   public var description: String {
-    String(_cxxString: SILType_debugDescription(bridged))
+    String(_cxxString: bridged.getDebugDescription())
   }
 }
 
 extension Type: Equatable {
   public static func ==(lhs: Type, rhs: Type) -> Bool { 
-    lhs.bridged.typePtr == rhs.bridged.typePtr
+    lhs.bridged == rhs.bridged
   }
 }
 
@@ -84,44 +86,44 @@ public struct NominalFieldsArray : RandomAccessCollection, FormattedLikeArray {
   fileprivate let function: Function
 
   public var startIndex: Int { return 0 }
-  public var endIndex: Int { SILType_getNumNominalFields(type.bridged) }
+  public var endIndex: Int { Int(type.bridged.getNumNominalFields()) }
 
   public subscript(_ index: Int) -> Type {
-    SILType_getNominalFieldType(type.bridged, index, function.bridged).type
+    type.bridged.getFieldType(index, function.bridged.getFunction()).type
   }
 
   public func getIndexOfField(withName name: String) -> Int? {
     let idx = name._withStringRef {
-      SILType_getFieldIdxOfNominalType(type.bridged, $0)
+      type.bridged.getFieldIdxOfNominalType($0)
     }
     return idx >= 0 ? idx : nil
   }
 
   public func getNameOfField(withIndex idx: Int) -> StringRef {
-    StringRef(bridged: SILType_getNominalFieldName(type.bridged, idx))
+    StringRef(bridged: type.bridged.getFieldName(idx))
   }
 }
 
 public struct TupleElementArray : RandomAccessCollection, FormattedLikeArray {
   fileprivate let type: Type
 
   public var startIndex: Int { return 0 }
-  public var endIndex: Int { SILType_getNumTupleElements(type.bridged) }
+  public var endIndex: Int { Int(type.bridged.getNumTupleElements()) }
 
   public subscript(_ index: Int) -> Type {
-    SILType_getTupleElementType(type.bridged, index).type
+    type.bridged.getTupleElementType(index).type
   }
 }
 
-extension BridgedType {
+extension swift.SILType {
   var type: Type { Type(bridged: self) }
 }
 
 // TODO: use an AST type for this once we have it
-public struct Decl : Equatable {
-  let bridged: BridgedDecl
+public struct NominalTypeDecl : Equatable {
+  let bridged: BridgedNominalTypeDecl
 
-  public static func ==(lhs: Decl, rhs: Decl) -> Bool {
-    lhs.bridged == rhs.bridged
+  public static func ==(lhs: NominalTypeDecl, rhs: NominalTypeDecl) -> Bool {
+    lhs.bridged.decl == rhs.bridged.decl
   }
 }

include/swift/SIL/SILBridging.h

@@ -16,6 +16,7 @@
 #include "swift/Basic/BasicBridging.h"
 #include "swift/Basic/BridgedSwiftObject.h"
 #include "swift/AST/Builtins.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILLocation.h"
@@ -43,10 +44,6 @@ typedef struct {
   const void * _Nonnull opaqueCtxt;
 } BridgedPassContext;
 
-typedef struct {
-  void * _Nullable typePtr;
-} BridgedType;
-
 struct BridgedValue {
   SwiftObject obj;
 
@@ -74,7 +71,7 @@ struct BridgedValue {
   inline OptionalBridgedOperand getFirstUse() const;
 
   SWIFT_IMPORT_UNSAFE
-  BridgedType getType() const { return {getSILValue()->getType().getOpaqueValue()}; }
+  swift::SILType getType() const { return getSILValue()->getType(); }
 
   Ownership getOwnership() const {
     switch (getSILValue()->getOwnershipKind()) {
@@ -130,9 +127,14 @@ struct BridgedOperandArray {
   SwiftInt count;
 };
 
-typedef struct {
+struct BridgedFunction {
   SwiftObject obj;
-} BridgedFunction;
+
+  SWIFT_IMPORT_UNSAFE
+  swift::SILFunction * _Nonnull getFunction() const {
+    return static_cast<swift::SILFunction *>(obj);
+  }
+};
 
 typedef struct {
   OptionalSwiftObject obj;
@@ -328,7 +330,9 @@ typedef enum {
 
 // AST bridging
 
-typedef void * _Nonnull BridgedDecl;
+struct BridgedNominalTypeDecl {
+  swift::NominalTypeDecl * _Nonnull decl;
+};
 
 struct BridgedEffectInfo {
   SwiftInt argumentIndex;
@@ -386,9 +390,9 @@ SwiftInt SILFunction_numIndirectResultArguments(BridgedFunction function);
 SwiftInt SILFunction_numParameterArguments(BridgedFunction function);
 SwiftInt SILFunction_getSelfArgumentIndex(BridgedFunction function);
 SwiftInt SILFunction_getNumSILArguments(BridgedFunction function);
-BridgedType SILFunction_getSILArgumentType(BridgedFunction function, SwiftInt idx);
+swift::SILType SILFunction_getSILArgumentType(BridgedFunction function, SwiftInt idx);
 BridgedArgumentConvention SILFunction_getSILArgumentConvention(BridgedFunction function, SwiftInt idx);
-BridgedType SILFunction_getSILResultType(BridgedFunction function);
+swift::SILType SILFunction_getSILResultType(BridgedFunction function);
 SwiftInt SILFunction_isSwift51RuntimeAvailable(BridgedFunction function);
 SwiftInt SILFunction_isPossiblyUsedExternally(BridgedFunction function);
 SwiftInt SILFunction_isAvailableExternally(BridgedFunction function);
@@ -412,7 +416,7 @@ OptionalBridgedInstruction SILBasicBlock_lastInst(BridgedBasicBlock block);
 SwiftInt SILBasicBlock_getNumArguments(BridgedBasicBlock block);
 BridgedArgument SILBasicBlock_getArgument(BridgedBasicBlock block, SwiftInt index);
 BridgedArgument SILBasicBlock_addBlockArgument(BridgedBasicBlock block,
-                                               BridgedType type,
+                                               swift::SILType type,
                                                BridgedValue::Ownership ownership);
 void SILBasicBlock_eraseArgument(BridgedBasicBlock block, SwiftInt index);
 void SILBasicBlock_moveAllInstructionsToBegin(BridgedBasicBlock block, BridgedBasicBlock dest);
@@ -422,35 +426,6 @@ OptionalBridgedSuccessor SILBasicBlock_getFirstPred(BridgedBasicBlock block);
 
 std::string SILNode_debugDescription(BridgedNode node);
 
-std::string SILType_debugDescription(BridgedType);
-SwiftInt SILType_isAddress(BridgedType);
-SwiftInt SILType_isTrivial(BridgedType, BridgedFunction);
-SwiftInt SILType_isReferenceCounted(BridgedType type, BridgedFunction);
-bool SILType_hasArchetype(BridgedType type);
-SwiftInt SILType_isNonTrivialOrContainsRawPointer(BridgedType, BridgedFunction);
-SwiftInt SILType_isNominal(BridgedType type);
-SwiftInt SILType_isClass(BridgedType type);
-SwiftInt SILType_isStruct(BridgedType type);
-SwiftInt SILType_isTuple(BridgedType type);
-SwiftInt SILType_isEnum(BridgedType type);
-bool SILType_isFunction(BridgedType type);
-bool SILType_isMetatype(BridgedType type);
-BridgedType SILType_instanceTypeOfMetatype(BridgedType type, BridgedFunction function);
-BridgedDecl SILType_getNominal(BridgedType type);
-bool SILType_isOrContainsObjectiveCClass(BridgedType type);
-bool SILType_isCalleeConsumedFunction(BridgedType type);
-bool SILType_isMarkedAsImmortal(BridgedType type);
-SwiftInt SILType_getNumTupleElements(BridgedType type);
-BridgedType SILType_getTupleElementType(BridgedType type, SwiftInt elementIdx);
-SwiftInt SILType_getNumNominalFields(BridgedType type);
-BridgedType SILType_getNominalFieldType(BridgedType type, SwiftInt index,
-                                        BridgedFunction function);
-SwiftInt SILType_getFieldIdxOfNominalType(BridgedType type,
-                                          llvm::StringRef fieldName);
-llvm::StringRef SILType_getNominalFieldName(BridgedType type, SwiftInt index);
-SwiftInt SILType_getCaseIdxOfEnumType(BridgedType type,
-                                      llvm::StringRef caseName);
-
 std::string SILLocation_debugDescription(swift::SILDebugLocation loc);
 swift::SILDebugLocation
 SILLocation_getAutogeneratedLocation(swift::SILDebugLocation loc);
@@ -547,21 +522,21 @@ SwiftInt FullApplySite_numIndirectResultArguments(BridgedInstruction inst);
 
 BridgedInstruction SILBuilder_createBuiltinBinaryFunction(
           BridgedBuilder builder, llvm::StringRef name,
-          BridgedType operandType, BridgedType resultType,
+          swift::SILType operandType, swift::SILType resultType,
           BridgedValueArray arguments);
 BridgedInstruction SILBuilder_createCondFail(BridgedBuilder builder,
           BridgedValue condition, llvm::StringRef message);
 BridgedInstruction SILBuilder_createIntegerLiteral(BridgedBuilder builder,
-          BridgedType type, SwiftInt value);
+          swift::SILType type, SwiftInt value);
 BridgedInstruction SILBuilder_createAllocStack(BridgedBuilder builder,
-          BridgedType type, SwiftInt hasDynamicLifetime, SwiftInt isLexical,
+          swift::SILType type, SwiftInt hasDynamicLifetime, SwiftInt isLexical,
           SwiftInt wasMoved);
 BridgedInstruction SILBuilder_createDeallocStack(BridgedBuilder builder,
           BridgedValue operand);
 BridgedInstruction SILBuilder_createDeallocStackRef(BridgedBuilder builder,
           BridgedValue operand);
 BridgedInstruction SILBuilder_createUncheckedRefCast(BridgedBuilder builder,
-          BridgedValue op, BridgedType type);
+          BridgedValue op, swift::SILType type);
 BridgedInstruction SILBuilder_createSetDeallocating(BridgedBuilder builder,
           BridgedValue op, bool isAtomic);
 BridgedInstruction SILBuilder_createFunctionRef(BridgedBuilder builder,
@@ -583,7 +558,7 @@ BridgedInstruction SILBuilder_createSwitchEnumInst(BridgedBuilder builder,
           const void * _Nullable enumCases, SwiftInt numEnumCases);
 BridgedInstruction SILBuilder_createUncheckedEnumData(BridgedBuilder builder,
           BridgedValue enumVal, SwiftInt caseIdx,
-          BridgedType resultType);
+          swift::SILType resultType);
 BridgedInstruction SILBuilder_createBranch(
           BridgedBuilder builder, BridgedBasicBlock destBlock,
           BridgedValueArray arguments);

include/swift/SIL/SILBridgingUtils.h

@@ -25,18 +25,10 @@
 
 namespace swift {
 
-inline SILType getSILType(BridgedType ty) {
-  return SILType::getFromOpaqueValue(ty.typePtr);
-}
-
 inline SILNode *castToSILNode(BridgedNode node) {
   return static_cast<SILNode *>(node.obj);
 }
 
-inline SILType castToSILType(BridgedType type) {
-  return SILType::getFromOpaqueValue(type.typePtr);
-}
-
 template <class I = SILInstruction> I *castToInst(BridgedInstruction inst) {
   return cast<I>(static_cast<SILNode *>(inst.obj)->castToInstruction());
 }