Fix parseSignatureBeforeBody

Author: intitni

Tool/Sources/FocusedCodeFinder/ObjectiveC/ObjectiveCCodeFinder.swift

@@ -19,7 +19,7 @@ public class ObjectiveCFocusedCodeFinder: KnownLanguageFocusedCodeFinder<
     ) {
         super.init(maxFocusedCodeLineCount: maxFocusedCodeLineCount)
     }
-    
+
     public func parseSyntaxTree(from document: Document) -> ASTTree? {
         let parser = ASTParser(language: .objectiveC)
         return parser.parse(document.content)
@@ -40,9 +40,9 @@ public class ObjectiveCFocusedCodeFinder: KnownLanguageFocusedCodeFinder<
             },
             range: range
         )
-        
+
         let nodes = visitor.findScopeHierarchy()
-        
+
         return .init(nodes: nodes, includes: visitor.includes, imports: visitor.imports)
     }
 
@@ -230,7 +230,7 @@ public class ObjectiveCFocusedCodeFinder: KnownLanguageFocusedCodeFinder<
         _ node: ASTNode,
         textProvider: @escaping TextProvider
     ) -> (nodeInfo: NodeInfo?, more: Bool) {
-        parseSignatureBeforeBody(node, textProvider: textProvider)
+        parseSignatureBeforeBody(node, fieldNameForName: "selector", textProvider: textProvider)
     }
 
     func parseFunctionDefinitionNode(
@@ -261,9 +261,10 @@ public class ObjectiveCFocusedCodeFinder: KnownLanguageFocusedCodeFinder<
 extension ObjectiveCFocusedCodeFinder {
     func parseSignatureBeforeBody(
         _ node: ASTNode,
+        fieldNameForName: String = "name",
         textProvider: @escaping TextProvider
     ) -> (nodeInfo: NodeInfo?, more: Bool) {
-        let name = node.contentOfChild(withFieldName: "name", textProvider: textProvider)
+        let name = node.contentOfChild(withFieldName: fieldNameForName, textProvider: textProvider)
         let (
             _,
             signatureRange,
@@ -303,30 +304,28 @@ extension ASTNode {
             return (nil, range, pointRange)
         }
 
-        let range = self.range.excluding(postfixNode.range)
-        let pointRange = self.pointRange.excluding(postfixNode.pointRange)
+        let range = self.range.subtracting(postfixNode.range)
+        let pointRange = self.pointRange.subtracting(postfixNode.pointRange)
         return (postfixNode, range, pointRange)
     }
 }
 
 extension NSRange {
-    func excluding(_ range: NSRange) -> NSRange {
-        let start = max(location, range.location)
-        let end = min(location + length, range.location + range.length)
+    func subtracting(_ range: NSRange) -> NSRange {
+        let start = lowerBound
+        let end = Swift.max(lowerBound, Swift.min(upperBound, range.lowerBound))
         return NSRange(location: start, length: end - start)
     }
 }
 
 extension Range where Bound == Point {
-    func excluding(_ range: Range<Bound>) -> Range<Bound> {
-        let start = Point(
-            row: Swift.max(lowerBound.row, range.lowerBound.row),
-            column: Swift.max(lowerBound.column, range.lowerBound.column)
-        )
-        let end = Point(
-            row: Swift.min(upperBound.row, range.upperBound.row),
-            column: Swift.min(upperBound.column, range.upperBound.column)
-        )
+    func subtracting(_ range: Range<Bound>) -> Range<Bound> {
+        let start = lowerBound
+        let end = if range.lowerBound >= upperBound {
+            upperBound
+        } else {
+            Swift.max(range.lowerBound, lowerBound)
+        }
         return Range(uncheckedBounds: (start, end))
     }
 }

Tool/Tests/FocusedCodeFinderTests/ObjectiveCFocusedCodeFinderTests.swift

@@ -3,3 +3,80 @@ import SuggestionModel
 import XCTest
 
 @testable import FocusedCodeFinder
+
+final class ObjectiveCFocusedCodeFinder_Selection_Tests: XCTestCase {
+    func test_selecting_a_line_inside_the_method_the_scope_should_be_the_method() {
+        let code = """
+        @implementation Foo
+        - (void)foo {
+            NSInteger foo = 0;
+            NSLog(@"Hello");
+            NSLog(@"World");
+        }
+        @end
+        """
+        let range = CursorRange(
+            start: CursorPosition(line: 2, character: 0),
+            end: CursorPosition(line: 2, character: 4)
+        )
+        let context = ObjectiveCFocusedCodeFinder().findFocusedCode(
+            in: document(code: code),
+            containingRange: range
+        )
+        XCTAssertEqual(context, .init(
+            scope: .scope(signature: [
+                .init(
+                    signature: "@implementation Foo",
+                    name: "Foo",
+                    range: .init(startPair: (0, 0), endPair: (6, 4))
+                ),
+                .init(
+                    signature: "- (void)foo",
+                    name: "foo",
+                    range: .init(startPair: (1, 0), endPair: (5, 1))
+                ),
+            ]),
+            contextRange: .init(startPair: (1, 0), endPair: (5, 1)),
+            focusedRange: range,
+            focusedCode: """
+                NSInteger foo = 0;
+
+            """,
+            imports: [],
+            includes: []
+        ))
+    }
+
+    func test_selecting_a_line_inside_a_function_the_scope_should_be_the_function() {
+        let code = """
+        void foo() {
+            NSInteger foo = 0;
+            NSLog(@"Hello");
+            NSLog(@"World");
+        }
+        """
+        let range = CursorRange(startPair: (2, 0), endPair: (2, 4))
+        let context = ObjectiveCFocusedCodeFinder().findFocusedCode(
+            in: document(code: code),
+            containingRange: range
+        )
+        XCTAssertEqual(context, .init(
+            scope: .scope(signature: [
+                .init(
+                    signature: "void foo()",
+                    name: "foo",
+                    range: .init(startPair: (0, 0), endPair: (4, 1))
+                ),
+            ]),
+            contextRange: .init(startPair: (0, 0), endPair: (4, 1)),
+            focusedRange: range,
+            focusedCode: """
+                NSLog(@"Hello");
+
+            """,
+            imports: [],
+            includes: []
+        ))
+    }
+}
+