Add ObjectiveCFocusedCodeFinder

Author: intitni

Pro

@@ -0,0 +1,61 @@
+import Foundation
+import SwiftTreeSitter
+
+public enum ASTTreeVisitorContinueKind {
+    /// The visitor should visit the descendants of the current node.
+    case visitChildren
+    /// The visitor should avoid visiting the descendants of the current node.
+    case skipChildren
+}
+
+// A SwiftSyntax style tree visitor.
+open class ASTTreeVisitor {
+    public let tree: ASTTree
+
+    public init(tree: ASTTree) {
+        self.tree = tree
+    }
+
+    public func walk() {
+        guard let cursor = tree.rootNode?.treeCursor else { return }
+        visit(cursor)
+    }
+    
+    public func walk(_ node: ASTNode) {
+        let cursor = node.treeCursor
+        visit(cursor)
+    }
+
+    open func visit(_: ASTNode) -> ASTTreeVisitorContinueKind {
+        // do nothing
+        return .skipChildren
+    }
+
+    open func visitPost(_: ASTNode) {
+        // do nothing
+    }
+
+    private func visit(_ cursor: TreeCursor) {
+        guard let currentNode = cursor.currentNode else { return }
+        let continueKind = visit(currentNode)
+
+        switch continueKind {
+        case .skipChildren:
+            visitPost(currentNode)
+        case .visitChildren:
+            visitChildren(cursor)
+            visitPost(currentNode)
+        }
+    }
+
+    private func visitChildren(_ cursor: TreeCursor) {
+        let hasChild = cursor.goToFirstChild()
+        guard hasChild else { return }
+        visit(cursor)
+        while cursor.goToNextSibling() {
+            visit(cursor)
+        }
+        _ = cursor.gotoParent()
+    }
+}
+

Tool/Sources/ASTParser/ASTTreeVisitor.swift

@@ -29,7 +29,14 @@ public struct CodeContext: Equatable {
     public var includes: [String]
 
     public static var empty: CodeContext {
-        .init(scope: .file, contextRange: .zero, focusedRange: .zero, focusedCode: "", imports: [])
+        .init(
+            scope: .file,
+            contextRange: .zero,
+            focusedRange: .zero,
+            focusedCode: "",
+            imports: [],
+            includes: []
+        )
     }
 
     public init(
@@ -51,19 +58,19 @@ public struct CodeContext: Equatable {
 
 public struct FocusedCodeFinder {
     public init() {}
-    
+
     public struct Document {
         var documentURL: URL
         var content: String
         var lines: [String]
-        
+
         public init(documentURL: URL, content: String, lines: [String]) {
             self.documentURL = documentURL
             self.content = content
             self.lines = lines
         }
     }
-    
+
     public func findFocusedCode(
         in document: Document,
         containingRange: CursorRange,
@@ -73,6 +80,8 @@ public struct FocusedCodeFinder {
             switch language {
             case .builtIn(.swift):
                 return SwiftFocusedCodeFinder()
+            case .builtIn(.objc), .builtIn(.objcpp), .builtIn(.c):
+                return ObjectiveCFocusedCodeFinder()
             default:
                 return UnknownLanguageFocusedCodeFinder(proposedSearchRange: 5)
             }
@@ -84,83 +93,10 @@ public struct FocusedCodeFinder {
 
 public protocol FocusedCodeFinderType {
     typealias Document = FocusedCodeFinder.Document
-    
+
     func findFocusedCode(
         in document: Document,
         containingRange: CursorRange
     ) -> CodeContext
 }
 
-public struct UnknownLanguageFocusedCodeFinder: FocusedCodeFinderType {
-    let proposedSearchRange: Int
-
-    public init(proposedSearchRange: Int) {
-        self.proposedSearchRange = proposedSearchRange
-    }
-
-    public func findFocusedCode(
-        in document: Document,
-        containingRange: CursorRange
-    ) -> CodeContext {
-        guard !document.lines.isEmpty else { return .empty }
-
-        // when user is not selecting any code.
-        if containingRange.start == containingRange.end {
-            // search up and down for up to `proposedSearchRange * 2 + 1` lines.
-            let lines = document.lines
-            let proposedLineCount = proposedSearchRange * 2 + 1
-            let startLineIndex = max(containingRange.start.line - proposedSearchRange, 0)
-            let endLineIndex = min(
-                max(
-                    startLineIndex,
-                    min(startLineIndex + proposedLineCount - 1, lines.count - 1)
-                ),
-                lines.count - 1
-            )
-
-            guard endLineIndex >= startLineIndex else { return .empty }
-            let focusedLines = lines[startLineIndex...endLineIndex]
-
-            let contextStartLine = max(startLineIndex - 5, 0)
-            let contextEndLine = min(endLineIndex + 5, lines.count - 1)
-
-            return .init(
-                scope: .top,
-                contextRange: .init(
-                    start: .init(line: contextStartLine, character: 0),
-                    end: .init(line: contextEndLine, character: lines[contextEndLine].count)
-                ),
-                focusedRange: .init(
-                    start: .init(line: startLineIndex, character: 0),
-                    end: .init(line: endLineIndex, character: lines[endLineIndex].count)
-                ),
-                focusedCode: focusedLines.joined(),
-                imports: []
-            )
-        }
-
-        let startLine = max(containingRange.start.line, 0)
-        let endLine = min(containingRange.end.line, document.lines.count - 1)
-
-        if endLine < startLine { return .empty }
-
-        let focusedLines = document.lines[startLine...endLine]
-        let contextStartLine = max(startLine - 3, 0)
-        let contextEndLine = min(endLine + 3, document.lines.count - 1)
-
-        return CodeContext(
-            scope: .top,
-            contextRange: .init(
-                start: .init(line: contextStartLine, character: 0),
-                end: .init(
-                    line: contextEndLine,
-                    character: document.lines[contextEndLine].count
-                )
-            ),
-            focusedRange: containingRange,
-            focusedCode: focusedLines.joined(),
-            imports: []
-        )
-    }
-}
-