Add tree sitter as AST parser

Author: intitni

Copilot for Xcode.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -0,0 +1,37 @@
+import Foundation
+import SwiftUI
+import AppKit
+import ASTParser
+import PlaygroundSupport
+
+struct ParsingForm: View {
+    @State var filePath: String = ""
+    @State var result: String = ""
+    
+    var body: some View {
+        Form {
+            Section("Input") {
+                TextField("File Path", text: $filePath)
+                Button("Parse") {
+                    result = ""
+                    Task {
+                        let fileContent = try String(contentsOfFile: filePath)
+                        let parser = ASTParser(language: .swift)
+                        let tree = parser.parse(fileContent)
+                        result = tree?.dump() ?? "N/A"
+                    }
+                }
+            }
+            
+            Section("Result") {
+                Text(result)
+                    .fontDesign(.monospaced)
+            }
+        }
+        .formStyle(.grouped)
+        .frame(width: 600, height: 800)
+    }
+}
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+PlaygroundPage.current.setLiveView(NSHostingController(rootView: ParsingForm()))

Playground.playground/Pages/ASTParsing.xcplaygroundpage/Contents.swift

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+   </TimelineItems>
+   <TimelineItems>
+   </TimelineItems>
+</Timeline>

Playground.playground/Pages/ASTParsing.xcplaygroundpage/timeline.xctimeline

@@ -3,5 +3,6 @@
     <pages>
         <page name='RetrievalQAChain'/>
         <page name='WebScrapper'/>
+        <page name='ASTParsing'/>
     </pages>
 </playground>

Playground.playground/contents.xcplayground

@@ -16,6 +16,7 @@ let package = Package(
         .library(name: "ChatTab", targets: ["ChatTab"]),
         .library(name: "Environment", targets: ["Environment"]),
         .library(name: "SuggestionModel", targets: ["SuggestionModel"]),
+        .library(name: "ASTParser", targets: ["ASTParser"]),
         .library(name: "Toast", targets: ["Toast"]),
         .library(name: "Keychain", targets: ["Keychain"]),
         .library(name: "SharedUIComponents", targets: ["SharedUIComponents"]),
@@ -44,6 +45,14 @@ let package = Package(
             url: "https://github.com/pointfreeco/swift-composable-architecture",
             from: "0.55.0"
         ),
+
+        // TreeSitter
+        .package(url: "https://github.com/ChimeHQ/SwiftTreeSitter", from: "0.7.1"),
+        .package(
+            url: "https://github.com/alex-pinkus/tree-sitter-swift",
+            branch: "with-generated-files"
+        ),
+        .package(url: "https://github.com/lukepistrol/tree-sitter-objc", branch: "feature/spm"),
     ],
     targets: [
         // MARK: - Helpers
@@ -142,6 +151,12 @@ let package = Package(
         ),
         .testTarget(name: "SharedUIComponentsTests", dependencies: ["SharedUIComponents"]),
 
+        .target(name: "ASTParser", dependencies: [
+            .product(name: "SwiftTreeSitter", package: "SwiftTreeSitter"),
+            .product(name: "TreeSitterObjC", package: "tree-sitter-objc"),
+            .product(name: "TreeSitterSwift", package: "tree-sitter-swift"),
+        ]),
+
         // MARK: - Services
 
         .target(

Tool/Package.swift

@@ -0,0 +1,42 @@
+import SwiftTreeSitter
+import tree_sitter
+import TreeSitterObjC
+import TreeSitterSwift
+
+public enum ParsableLanguage {
+    case swift
+    case objectiveC
+
+    var tsLanguage: UnsafeMutablePointer<TSLanguage> {
+        switch self {
+        case .swift:
+            return tree_sitter_swift()
+        case .objectiveC:
+            return tree_sitter_objc()
+        }
+    }
+}
+
+public struct ASTParser {
+    let language: ParsableLanguage
+    let parser: Parser
+
+    public init(language: ParsableLanguage) {
+        self.language = language
+        parser = Parser()
+        try! parser.setLanguage(Language(language: language.tsLanguage))
+    }
+
+    public func parse(_ source: String) -> ASTTree? {
+        return ASTTree(tree: parser.parse(source))
+    }
+}
+
+public struct ASTTree {
+    public let tree: Tree?
+
+    public var rootNode: Node? {
+        return tree?.rootNode
+    }
+}
+

Tool/Sources/ASTParser/ASTParser.swift

@@ -0,0 +1,71 @@
+import SwiftTreeSitter
+
+public extension ASTTree {
+    /// Dumps the syntax tree as a string, for debugging purposes.
+    func dump() -> String {
+        guard let tree, let root = tree.rootNode else { return "" }
+        var result = ""
+
+        let appendNode: (_ level: Int, _ node: Node) -> Void = { level, node in
+            let line =
+                "\(String(repeating: "  ", count: level))\(node.nodeType ?? "N/A") \(node.pointRange)"
+            result += line + "\n"
+        }
+
+        guard let node = root.descendant(in: root.byteRange) else { return result }
+
+        appendNode(0, node)
+
+        let cursor = node.treeCursor
+        let level = 1
+
+        if cursor.goToFirstChild(for: node.byteRange.lowerBound) == false {
+            return result
+        }
+
+        cursor.enumerateCurrentAndDescendents(level: level + 1) { level, node in
+            appendNode(level, node)
+        }
+
+        while cursor.gotoNextSibling() {
+            guard let node = cursor.currentNode else {
+                assertionFailure("no current node when gotoNextSibling succeeded")
+                break
+            }
+
+            // once we are past the interesting range, stop
+            if node.byteRange.lowerBound > root.byteRange.upperBound {
+                break
+            }
+
+            cursor.enumerateCurrentAndDescendents(level: level + 1) { level, node in
+                appendNode(level, node)
+            }
+        }
+
+        return result
+    }
+}
+
+private extension TreeCursor {
+    func enumerateCurrentAndDescendents(level: Int, block: (Int, Node) throws -> Void) rethrows {
+        if let node = currentNode {
+            try block(level, node)
+        }
+
+        if goToFirstChild() == false {
+            return
+        }
+
+        try enumerateCurrentAndDescendents(level: level + 1, block: block)
+
+        while gotoNextSibling() {
+            try enumerateCurrentAndDescendents(level: level + 1, block: block)
+        }
+
+        let success = gotoParent()
+
+        assert(success)
+    }
+}
+