Add integerValue to IntegerLiteralExprSyntax

Update Convenience.swift

Update Convenience.swift

Author: kimdv

Sources/SwiftRefactor/IntegerLiteralUtilities.swift

@@ -17,46 +17,6 @@ import SwiftSyntax
 #endif
 
 extension IntegerLiteralExprSyntax {
-  public enum Radix {
-    case binary
-    case octal
-    case decimal
-    case hex
-
-    public var size: Int {
-      switch self {
-      case .binary: return 2
-      case .octal: return 8
-      case .decimal: return 10
-      case .hex: return 16
-      }
-    }
-
-    /// The prefix that is used to express an integer literal with this
-    /// radix in Swift source code, e.g., "0x" for hexadecimal.
-    public var literalPrefix: String {
-      switch self {
-      case .binary: return "0b"
-      case .octal: return "0o"
-      case .hex: return "0x"
-      case .decimal: return ""
-      }
-    }
-  }
-
-  public var radix: Radix {
-    let text = self.literal.text
-    if text.starts(with: "0b") {
-      return .binary
-    } else if text.starts(with: "0o") {
-      return .octal
-    } else if text.starts(with: "0x") {
-      return .hex
-    } else {
-      return .decimal
-    }
-  }
-
   /// Returns an (arbitrarily) "ideal" number of digits that should constitute
   /// a separator-delimited "group" in an integer literal.
   var idealGroupSize: Int {

Sources/SwiftSyntax/Convenience.swift

@@ -68,6 +68,75 @@ extension EnumCaseParameterSyntax {
   }
 }
 
+extension IntegerLiteralExprSyntax {
+  public enum Radix {
+    case binary
+    case octal
+    case decimal
+    case hex
+
+    public var size: Int {
+      switch self {
+      case .binary: return 2
+      case .octal: return 8
+      case .decimal: return 10
+      case .hex: return 16
+      }
+    }
+
+    /// The prefix that is used to express an integer literal with this
+    /// radix in Swift source code, e.g., "0x" for hexadecimal.
+    public var literalPrefix: String {
+      switch self {
+      case .binary: return "0b"
+      case .octal: return "0o"
+      case .hex: return "0x"
+      case .decimal: return ""
+      }
+    }
+
+    fileprivate var offset: Int {
+      switch self {
+      case .binary, .hex, .octal:
+        return 2
+      case .decimal:
+        return 0
+      }
+    }
+  }
+
+  public var radix: Radix {
+    let text = self.literal.text
+    if text.starts(with: "0b") {
+      return .binary
+    } else if text.starts(with: "0o") {
+      return .octal
+    } else if text.starts(with: "0x") {
+      return .hex
+    } else {
+      return .decimal
+    }
+  }
+
+  /// A computed property representing the integer value parsed from the associated `literal.text` property, considering the specified radix.
+  ///
+  /// - Returns: An integer value parsed from the associated `literal.text`, or `nil` if the text cannot be parsed as an integer.
+  public var representedLiteralValue: Int? {
+    guard !hasError else { return nil }
+
+    let text = literal.text
+    let radix = self.radix
+    let digitsStartIndex = text.index(text.startIndex, offsetBy: radix.offset)
+    let textWithoutPrefix = text.suffix(from: digitsStartIndex)
+
+    let textWithoutPrefixOrUnderscores = textWithoutPrefix.filter {
+      $0 != "_"
+    }
+
+    return Int(textWithoutPrefixOrUnderscores, radix: radix.size)
+  }
+}
+
 extension MemberAccessExprSyntax {
   /// Creates a new ``MemberAccessExprSyntax`` where the accessed member is represented by
   /// an identifier without specifying argument labels.

Tests/SwiftSyntaxTest/SyntaxTests.swift

@@ -168,4 +168,34 @@ class SyntaxTests: XCTestCase {
     XCTAssertEqual(funcKeywordInTree2?.as(TokenSyntax.self)?.tokenKind, .keyword(.func))
     XCTAssertNotEqual(funcKeywordInTree1.id, funcKeywordInTree2?.id)
   }
+
+  func testIntegerLiteralExprSyntax() {
+    let testCases: [UInt: (String, Int?)] = [
+      #line: ("2", 2),
+      #line: ("02", 2),
+      #line: ("020", 20),
+      #line: ("-02", -2),
+      #line: ("2_00_0000", 2_00_0000),
+      #line: ("-2_00_0000", -2_00_0000),
+      #line: ("foo", nil),
+      #line: ("999999999999999999999999999999999999999999999999999999999999999999999999999999", nil),
+      #line: ("0b1010101", 85),
+      #line: ("0xFF", 255),
+      #line: ("0o777", 511),
+      #line: ("0b001100", 0b001100),
+      #line: ("4_2", 4_2),
+      #line: ("0o3434", 0o3434),
+      #line: ("0xba11aD", 0xba11aD),
+      #line: ("🐋", nil),
+      #line: ("-0xA", nil),
+      #line: ("-0o7", nil),
+      #line: ("-0b1", nil),
+    ]
+
+    for (line, testCase) in testCases {
+      let (value, expected) = testCase
+      let expr = IntegerLiteralExprSyntax(literal: .integerLiteral(value))
+      XCTAssertEqual(expr.representedLiteralValue, expected, line: line)
+    }
+  }
 }