add util properties for TypeSyntaxProtocol

Author: hnrklssn

lib/Macros/Sources/SwiftMacros/PointerBoundsMacro.swift

@@ -315,7 +315,7 @@ struct CountedOrSizedPointerThunkBuilder: PointerBoundsThunkBuilder {
   }
 
   func castIntToTargetType(expr: ExprSyntax, type: TypeSyntax) -> ExprSyntax {
-    if type.isSwiftInt {
+    if type.canRepresentBasicType(type: Int.self) {
       return expr
     }
     return ExprSyntax("\(type)(exactly: \(expr))!")
@@ -717,3 +717,49 @@ public struct PointerBoundsMacro: PeerMacro {
     }
   }
 }
+
+// MARK: syntax utils
+extension TypeSyntaxProtocol {
+  public var isSwiftCoreModule: Bool {
+    guard let identifierType = self.as(IdentifierTypeSyntax.self) else {
+      return false
+    }
+    return identifierType.name.text == "Swift"
+  }
+
+  /// Check if this syntax could resolve to the type passed. Only supports types where the canonical type
+  /// can be named using only IdentifierTypeSyntax and MemberTypeSyntax. A non-exhaustive list of unsupported
+  /// types includes:
+  /// * array types
+  /// * function types
+  /// * optional types
+  /// * tuple types (including Void!)
+  /// The type syntax is allowed to use any level of qualified name for the type, e.g. Swift.Int.self
+  /// will match against both "Swift.Int" and "Int".
+  ///
+  /// - Parameter type: Type to check against. NB: if passing a type alias, the canonical type will be used.
+  /// - Returns: true if `self` spells out some suffix of the fully qualified name of `type`, otherwise false
+  public func canRepresentBasicType(type: Any.Type) -> Bool {
+    let qualifiedTypeName = String(reflecting: type)
+    var typeNames = qualifiedTypeName.split(separator: ".")
+    var currType: TypeSyntaxProtocol = self
+
+    while !typeNames.isEmpty {
+      let typeName = typeNames.popLast()!
+      if let identifierType = currType.as(IdentifierTypeSyntax.self) {
+        // It doesn't matter whether this is the final element of typeNames, because we don't know
+        // surrounding context - the Foo.Bar.Baz type can be referred to as `Baz` inside Foo.Bar
+        return identifierType.name.text == typeName
+      } else if let memberType = currType.as(MemberTypeSyntax.self) {
+        if memberType.name.text != typeName {
+          return false
+        }
+        currType = memberType.baseType
+      } else {
+        return false
+      }
+    }
+
+    return false
+  }
+}