SwiftCompilerSources: bridge SILDeclRef

And move NominalTypeDecl and DeclRef from Type.swift into a new file Declarations.swift.
Also add some APIs to NominalTypeDecl

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/DiagnosticEngine.swift

@@ -13,6 +13,7 @@
 import ASTBridging
 
 import Basic
+import SIL
 
 public typealias DiagID = BridgedDiagID
 
@@ -29,6 +30,11 @@ extension Int: DiagnosticArgument {
     fn(BridgedDiagnosticArgument(self))
   }
 }
+extension DeclRef: DiagnosticArgument {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+    fn(bridged.asDiagnosticArgument())
+  }
+}
 
 public struct DiagnosticFixIt {
   public let start: SourceLoc

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -14,6 +14,7 @@ add_swift_compiler_module(SIL
     Argument.swift
     BasicBlock.swift
     Builder.swift
+    Declarations.swift
     Effects.swift
     ForwardingInstruction.swift
     Function.swift

SwiftCompilerSources/Sources/SIL/Declarations.swift

@@ -0,0 +1,66 @@
+//===--- Declarations.swift -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 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 SILBridging
+
+// TODO: move all declarations to an AST module, once we have it
+
+public struct NominalTypeDecl : Equatable, Hashable {
+  public let bridged: BridgedNominalTypeDecl
+
+  public init(_bridged: BridgedNominalTypeDecl) {
+    self.bridged = _bridged
+  }
+
+  public var name: StringRef { StringRef(bridged: bridged.getName()) }
+
+  public static func ==(lhs: NominalTypeDecl, rhs: NominalTypeDecl) -> Bool {
+    lhs.bridged.raw == rhs.bridged.raw
+  }
+
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(bridged.raw)
+  }
+
+  public var location: Location { Location(bridged: BridgedLocation.fromNominalTypeDecl(bridged)) }
+
+  public func isResilient(in function: Function) -> Bool {
+    function.bridged.isResilientNominalDecl(bridged)
+  }
+
+  public var isStructWithUnreferenceableStorage: Bool {
+    bridged.isStructWithUnreferenceableStorage()
+  }
+
+  public var isGlobalActor: Bool {
+    return bridged.isGlobalActor()
+  }
+
+  public var hasValueDeinit: Bool {
+    return bridged.hasValueDeinit()
+  }
+
+  public var isClass: Bool { bridged.isClass() }
+
+  public var superClassType: Type? {
+    precondition(isClass)
+    return BridgedType.getSuperClassTypeOfClassDecl(bridged).typeOrNil
+  }
+
+  public var isGenericAtAnyLevel: Bool { bridged.isGenericAtAnyLevel() }
+}
+
+public struct DeclRef {
+  public let bridged: BridgedDeclRef
+
+  public var location: Location { Location(bridged: bridged.getLocation()) }
+}

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -314,38 +314,3 @@ extension BridgedType {
   public var type: Type { Type(bridged: self) }
   var typeOrNil: Type? { isNull() ? nil : type }
 }
-
-// TODO: use an AST type for this once we have it
-public struct NominalTypeDecl : Equatable, Hashable {
-  public let bridged: BridgedNominalTypeDecl
-
-  public init(_bridged: BridgedNominalTypeDecl) {
-    self.bridged = _bridged
-  }
-
-  public var name: StringRef { StringRef(bridged: bridged.getName()) }
-
-  public static func ==(lhs: NominalTypeDecl, rhs: NominalTypeDecl) -> Bool {
-    lhs.bridged.raw == rhs.bridged.raw
-  }
-
-  public func hash(into hasher: inout Hasher) {
-    hasher.combine(bridged.raw)
-  }
-
-  public func isResilient(in function: Function) -> Bool {
-    function.bridged.isResilientNominalDecl(bridged)
-  }
-
-  public var isStructWithUnreferenceableStorage: Bool {
-    bridged.isStructWithUnreferenceableStorage()
-  }
-
-  public var isGlobalActor: Bool {
-    return bridged.isGlobalActor()
-  }
-
-  public var hasValueDeinit: Bool {
-    return bridged.hasValueDeinit()
-  }
-}

include/swift/AST/ASTBridging.h

@@ -1112,6 +1112,14 @@ SWIFT_NAME("BridgedNominalTypeDecl.hasValueDeinit(self:)")
 BRIDGED_INLINE
 bool BridgedNominalTypeDecl_hasValueDeinit(BridgedNominalTypeDecl decl);
 
+SWIFT_NAME("BridgedNominalTypeDecl.isClass(self:)")
+BRIDGED_INLINE
+bool BridgedNominalTypeDecl_isClass(BridgedNominalTypeDecl decl);
+
+SWIFT_NAME("BridgedNominalTypeDecl.isGenericAtAnyLevel(self:)")
+BRIDGED_INLINE
+bool BridgedNominalTypeDecl_isGenericAtAnyLevel(BridgedNominalTypeDecl decl);
+
 SWIFT_NAME("BridgedNominalTypeDecl.setParsedMembers(self:_:)")
 void BridgedNominalTypeDecl_setParsedMembers(BridgedNominalTypeDecl decl,
                                              BridgedArrayRef members);

include/swift/AST/ASTBridgingImpl.h

@@ -45,6 +45,14 @@ bool BridgedNominalTypeDecl_hasValueDeinit(BridgedNominalTypeDecl decl) {
   return decl.unbridged()->getValueTypeDestructor() != nullptr;
 }
 
+bool BridgedNominalTypeDecl_isClass(BridgedNominalTypeDecl decl) {
+  return swift::isa<swift::ClassDecl>(decl.unbridged());
+}
+
+bool BridgedNominalTypeDecl_isGenericAtAnyLevel(BridgedNominalTypeDecl decl) {
+  return decl.unbridged()->isGenericContext();
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedSubscriptDecl
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILBridging.h

@@ -336,6 +336,8 @@ struct BridgedType {
   getTupleElementType(SwiftInt idx) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getFunctionTypeWithNoEscape(bool withNoEscape) const;
   BRIDGED_INLINE BridgedArgumentConvention getCalleeConvention() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
+  static BridgedType getSuperClassTypeOfClassDecl(BridgedNominalTypeDecl decl);
 };
 
 // SIL Bridging
@@ -470,6 +472,7 @@ struct BridgedLocation {
   BRIDGED_INLINE bool isEqualTo(BridgedLocation rhs) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedSourceLoc getSourceLocation() const;
   BRIDGED_INLINE bool hasSameSourceLocation(BridgedLocation rhs) const;
+  static BRIDGED_INLINE BridgedLocation fromNominalTypeDecl(BridgedNominalTypeDecl decl);
   static BRIDGED_INLINE BridgedLocation getArtificialUnreachableLocation();
 };
 
@@ -1067,6 +1070,23 @@ struct BridgedSuccessorArray {
   SwiftInt count;
 };
 
+struct BridgedDeclRef {
+  uint64_t storage[3];
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedDeclRef(swift::SILDeclRef declRef) {
+    *reinterpret_cast<swift::SILDeclRef *>(&storage) = declRef;
+  }
+
+  swift::SILDeclRef unbridged() const {
+    return *reinterpret_cast<const swift::SILDeclRef *>(&storage);
+  }
+#endif
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedLocation getLocation() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDiagnosticArgument asDiagnosticArgument() const;
+};
+
 struct BridgedVTableEntry {
   const swift::SILVTableEntry * _Nonnull entry;
 

include/swift/SIL/SILBridgingImpl.h

@@ -531,6 +531,14 @@ BridgedArgumentConvention BridgedType::getCalleeConvention() const {
   return getArgumentConvention(fnType->getCalleeConvention());
 }
 
+BridgedType BridgedType::getSuperClassTypeOfClassDecl(BridgedNominalTypeDecl decl) {
+  swift::Type superTy = swift::cast<swift::ClassDecl>(decl.unbridged())->getSuperclass();
+  if (!superTy) {
+    return BridgedType(swift::SILType());
+  }
+  return swift::SILType::getPrimitiveObjectType(superTy->getCanonicalType());
+}
+
 //===----------------------------------------------------------------------===//
 //                                BridgedValue
 //===----------------------------------------------------------------------===//
@@ -718,6 +726,9 @@ BridgedSourceLoc BridgedLocation::getSourceLocation() const {
 bool BridgedLocation::hasSameSourceLocation(BridgedLocation rhs) const {
   return getLoc().hasSameSourceLocation(rhs.getLoc());
 }
+BridgedLocation BridgedLocation::fromNominalTypeDecl(BridgedNominalTypeDecl decl) {
+  return swift::SILDebugLocation(decl.unbridged(), nullptr);
+}
 BridgedLocation BridgedLocation::getArtificialUnreachableLocation() {
   return swift::SILDebugLocation::getArtificialUnreachableLocation();
 }
@@ -1703,6 +1714,21 @@ BridgedSuccessor OptionalBridgedSuccessor::advancedBy(SwiftInt index) const {
   return {succ + index};
 }
 
+//===----------------------------------------------------------------------===//
+//                                BridgedDeclRef
+//===----------------------------------------------------------------------===//
+
+static_assert(sizeof(BridgedDeclRef) >= sizeof(swift::SILDeclRef),
+              "BridgedDeclRef has wrong size");
+
+BridgedLocation BridgedDeclRef::getLocation() const {
+  return swift::SILDebugLocation(unbridged().getDecl(), nullptr);
+}
+
+BridgedDiagnosticArgument BridgedDeclRef::asDiagnosticArgument() const {
+  return swift::DiagnosticArgument(unbridged().getDecl()->getName());
+}
+
 //===----------------------------------------------------------------------===//
 //                                BridgedVTable
 //===----------------------------------------------------------------------===//