Skip to content

Commit adf8137

Browse files
StevenWong12StevenWong12
committed
Add assertClassification for ClassificationTests 
1 parent e990c2a commit adf8137

File tree

3 files changed

+179
-165
lines changed

3 files changed

+179
-165
lines changed

‎Sources/_SwiftSyntaxTestSupport/IncrementalParseTestUtils.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -125,7 +125,7 @@ public func assertIncrementalParse(
125125
}
126126
}
127127

128-
fileprivate func byteSourceRange(for substring: String, in sourceString: String, after: String.Index) -> ByteSourceRange? {
128+
public func byteSourceRange(for substring: String, in sourceString: String, after: String.Index) -> ByteSourceRange? {
129129
if let range = sourceString[after...].range(of: substring) {
130130
return ByteSourceRange(
131131
offset: sourceString.utf8.distance(from: sourceString.startIndex, to: range.lowerBound),

‎Tests/SwiftIDEUtilsTest/Assertions.swift

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
//===----------------------------------------------------------------------===//
2+
//
3+
// This source file is part of the Swift.org open source project
4+
//
5+
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
6+
// Licensed under Apache License v2.0 with Runtime Library Exception
7+
//
8+
// See https://swift.org/LICENSE.txt for license information
9+
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
10+
//
11+
//===----------------------------------------------------------------------===//
12+
13+
import XCTest
14+
import SwiftIDEUtils
15+
import SwiftParser
16+
import SwiftSyntax
17+
import _SwiftSyntaxTestSupport
18+
19+
/// Parse `source` and checks its `classifications` is the same as `expected`. The `classification` filter out all the ``Trivia``s in `source` i.e. ``SyntaxClassification`` is `none` to make test cases look nicer.
20+
///
21+
/// - Parameters:
22+
/// - expected: The element order should respect to the order of `ClassificationSpec.source` in `source`
23+
/// - range: An optional parameter to specify the ``ByteSourceRange`` in `source` that we want to test the `classifications` in
24+
func assertClassification(
25+
_ source: String,
26+
expected: [ClassificationSpec],
27+
in range: ByteSourceRange? = nil,
28+
file: StaticString = #file,
29+
line: UInt = #line
30+
) {
31+
let tree = Parser.parse(source: source)
32+
33+
var classifications = Array(tree.classifications).filter { $0.kind != .none }
34+
if let range {
35+
classifications = classifications.filter { ($0.offset >= range.offset) && ($0.endOffset <= range.endOffset) }
36+
}
37+
38+
if expected.count != classifications.count {
39+
XCTFail("Expected \(expected.count) re-used nodes but received \(classifications.count)", file: file, line: line)
40+
}
41+
42+
var lastRangeUpperBound = source.startIndex
43+
for (classification, spec) in zip(classifications, expected) {
44+
guard let range = byteSourceRange(for: spec.source, in: source, after: lastRangeUpperBound) else {
45+
XCTFail("Fail to find string in original source,", file: spec.file, line: spec.line)
46+
continue
47+
}
48+
49+
XCTAssertEqual(
50+
range,
51+
classification.range,
52+
"""
53+
Expected \(range) but received \(classification.range)
54+
""",
55+
file: spec.file,
56+
line: spec.line
57+
)
58+
59+
XCTAssertEqual(
60+
spec.kind,
61+
classification.kind,
62+
"""
63+
Expected \(spec.kind) syntax classification kind but received \(classification.kind)
64+
""",
65+
file: spec.file,
66+
line: spec.line
67+
)
68+
69+
lastRangeUpperBound = source.index(source.startIndex, offsetBy: range.endOffset)
70+
}
71+
}
72+
73+
/// An abstract data structure to describe a source code snippet and its ``SyntaxClassification``.
74+
public struct ClassificationSpec {
75+
/// Source code without any ``Trivia``
76+
let source: String
77+
/// The ``SyntaxClassification`` of the source code,
78+
let kind: SyntaxClassification
79+
/// The file and line at which this ``ClassificationSpec`` was created, so that assertion failures can be reported at its location.
80+
let file: StaticString
81+
let line: UInt
82+
83+
public init(
84+
source: String,
85+
kind: SyntaxClassification,
86+
file: StaticString = #file,
87+
line: UInt = #line
88+
) {
89+
self.source = source
90+
self.kind = kind
91+
self.file = file
92+
self.line = line
93+
}
94+
}

‎Tests/SwiftIDEUtilsTest/ClassificationTests.swift

Lines changed: 84 additions & 164 deletions
Original file line numberDiff line numberDiff line change
@@ -19,181 +19,101 @@ import _SwiftSyntaxTestSupport
1919
public class ClassificationTests: XCTestCase {
2020

2121
public func testClassification() {
22-
let source = """
22+
assertClassification(
23+
"""
2324
// blah.
2425
let x/*yo*/ = 0
26+
""",
27+
expected: [
28+
ClassificationSpec(source: "// blah.", kind: .lineComment),
29+
ClassificationSpec(source: "let", kind: .keyword),
30+
ClassificationSpec(source: "x", kind: .identifier),
31+
ClassificationSpec(source: "/*yo*/", kind: .blockComment),
32+
ClassificationSpec(source: "0", kind: .integerLiteral),
33+
]
34+
)
35+
36+
assertClassification(
37+
"x/*yo*/ ",
38+
expected: [ClassificationSpec(source: "/*yo*/", kind: .blockComment)],
39+
in: ByteSourceRange(offset: 1, length: 6)
40+
)
41+
}
42+
43+
public func testClassificationInCertainRange() {
44+
assertClassification(
2545
"""
26-
let tree = Parser.parse(source: source)
27-
do {
28-
let classif = Array(tree.classifications)
29-
XCTAssertEqual(classif.count, 8)
30-
guard classif.count == 8 else {
31-
return
32-
}
33-
XCTAssertEqual(classif[0].kind, .lineComment)
34-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 8))
35-
XCTAssertEqual(classif[1].kind, .none)
36-
XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 8, length: 1))
37-
XCTAssertEqual(classif[2].kind, .keyword)
38-
XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 9, length: 3))
39-
XCTAssertEqual(classif[3].kind, .none)
40-
XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 12, length: 1))
41-
XCTAssertEqual(classif[4].kind, .identifier)
42-
XCTAssertEqual(classif[4].range, ByteSourceRange(offset: 13, length: 1))
43-
XCTAssertEqual(classif[5].kind, .blockComment)
44-
XCTAssertEqual(classif[5].range, ByteSourceRange(offset: 14, length: 6))
45-
XCTAssertEqual(classif[6].kind, .none)
46-
XCTAssertEqual(classif[6].range, ByteSourceRange(offset: 20, length: 3))
47-
XCTAssertEqual(classif[7].kind, .integerLiteral)
48-
XCTAssertEqual(classif[7].range, ByteSourceRange(offset: 23, length: 1))
49-
}
50-
do {
51-
let classif = Array(tree.classifications(in: ByteSourceRange(offset: 7, length: 8)))
52-
XCTAssertEqual(classif.count, 6)
53-
guard classif.count == 6 else {
54-
return
55-
}
56-
XCTAssertEqual(classif[0].kind, .lineComment)
57-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 8))
58-
XCTAssertEqual(classif[1].kind, .none)
59-
XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 8, length: 1))
60-
XCTAssertEqual(classif[2].kind, .keyword)
61-
XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 9, length: 3))
62-
XCTAssertEqual(classif[3].kind, .none)
63-
XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 12, length: 1))
64-
XCTAssertEqual(classif[4].kind, .identifier)
65-
XCTAssertEqual(classif[4].range, ByteSourceRange(offset: 13, length: 1))
66-
XCTAssertEqual(classif[5].kind, .blockComment)
67-
XCTAssertEqual(classif[5].range, ByteSourceRange(offset: 14, length: 6))
68-
}
69-
do {
70-
let classif = Array(tree.classifications(in: ByteSourceRange(offset: 21, length: 1)))
71-
XCTAssertEqual(classif.count, 1)
72-
guard classif.count == 1 else {
73-
return
74-
}
75-
XCTAssertEqual(classif[0].kind, .none)
76-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 21, length: 2))
77-
}
78-
do {
79-
let pattern = (tree.statements[0].item.as(VariableDeclSyntax.self)!).bindings[0].pattern
80-
XCTAssertEqual(pattern.description, "x/*yo*/ ")
81-
// Classify with a relative range inside this node.
82-
let classif = Array(pattern.classifications(in: ByteSourceRange(offset: 5, length: 2)))
83-
XCTAssertEqual(classif.count, 2)
84-
guard classif.count == 2 else {
85-
return
86-
}
87-
XCTAssertEqual(classif[0].kind, .blockComment)
88-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 14, length: 6))
89-
XCTAssertEqual(classif[1].kind, .none)
90-
XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 20, length: 1))
46+
// blah.
47+
let x/*yo*/ = 0
48+
""",
49+
expected: [
50+
ClassificationSpec(source: "let", kind: .keyword),
51+
ClassificationSpec(source: "x", kind: .identifier),
52+
],
53+
in: ByteSourceRange(offset: 7, length: 8)
54+
)
55+
}
9156

92-
do {
93-
let singleClassif = pattern.classification(at: 5)
94-
XCTAssertEqual(singleClassif, classif[0])
95-
}
96-
do {
97-
let singleClassif = pattern.classification(at: AbsolutePosition(utf8Offset: 19))
98-
XCTAssertEqual(singleClassif, classif[0])
99-
}
100-
}
57+
public func testClassificationInEmptyRange() {
58+
assertClassification(
59+
"""
60+
// blah.
61+
let x/*yo*/ = 0
62+
""",
63+
expected: [],
64+
in: ByteSourceRange(offset: 21, length: 2)
65+
)
66+
}
67+
68+
public func testClassificationAt() throws {
69+
let tree = Parser.parse(source: "func foo() {}")
70+
let keyword = try XCTUnwrap(tree.classification(at: 3))
71+
let identifier = try XCTUnwrap(tree.classification(at: AbsolutePosition(utf8Offset: 6)))
72+
73+
XCTAssertEqual(keyword.kind, .keyword)
74+
XCTAssertEqual(keyword.range, ByteSourceRange(offset: 0, length: 4))
10175

102-
do {
103-
let source = "func foo() {}"
104-
let tree = Parser.parse(source: source)
105-
// For `classification(at:)` there's an initial walk to find the token that
106-
// the offset is contained in and the classified ranges are processed from that
107-
// token. That means that a `none` classified range would be restricted inside
108-
// the token range.
109-
let classif = tree.classification(at: 11)!
110-
XCTAssertEqual(classif.kind, .none)
111-
XCTAssertEqual(classif.range, ByteSourceRange(offset: 11, length: 1))
112-
}
76+
XCTAssertEqual(identifier.kind, .identifier)
77+
XCTAssertEqual(identifier.range, ByteSourceRange(offset: 5, length: 3))
11378
}
11479

11580
public func testTokenClassification() {
116-
let source = "let x: Int"
117-
let tree = Parser.parse(source: source)
118-
do {
119-
let tokens = Array(tree.tokens(viewMode: .sourceAccurate))
120-
XCTAssertEqual(tokens.count, 5)
121-
guard tokens.count == 5 else {
122-
return
123-
}
124-
let classif = tokens.map { $0.tokenClassification }
125-
XCTAssertEqual(classif[0].kind, .keyword)
126-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 3))
127-
XCTAssertEqual(classif[1].kind, .identifier)
128-
XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 4, length: 1))
129-
XCTAssertEqual(classif[2].kind, .none)
130-
XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 5, length: 1))
131-
XCTAssertEqual(classif[3].kind, .typeIdentifier)
132-
XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 7, length: 3))
133-
XCTAssertEqual(classif[4].kind, .none)
134-
XCTAssertEqual(classif[4].range, ByteSourceRange(offset: 10, length: 0))
135-
}
136-
do {
137-
let tok = tree.lastToken(viewMode: .sourceAccurate)!.previousToken(viewMode: .sourceAccurate)!
138-
XCTAssertEqual("\(tok)", "Int")
139-
let classif = Array(tok.classifications).first!
140-
XCTAssertEqual(classif.kind, .typeIdentifier)
141-
}
81+
assertClassification(
82+
"""
83+
let x: Int
84+
""",
85+
expected: [
86+
ClassificationSpec(source: "let", kind: .keyword),
87+
ClassificationSpec(source: "x", kind: .identifier),
88+
ClassificationSpec(source: "Int", kind: .typeIdentifier),
89+
]
90+
)
14291
}
14392

14493
public func testOperatorTokenClassification() {
145-
do {
146-
let source = "let x: Int = 4 + 5 / 6"
147-
let tree = Parser.parse(source: source)
148-
149-
let tokens = Array(tree.tokens(viewMode: .sourceAccurate))
150-
XCTAssertEqual(tokens.count, 11)
151-
guard tokens.count == 11 else {
152-
return
153-
}
154-
let classif = tokens.map { $0.tokenClassification }
155-
XCTAssertEqual(classif[0].kind, .keyword)
156-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 3))
157-
XCTAssertEqual(classif[1].kind, .identifier)
158-
XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 4, length: 1))
159-
XCTAssertEqual(classif[2].kind, .none)
160-
XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 5, length: 1))
161-
XCTAssertEqual(classif[3].kind, .typeIdentifier)
162-
XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 7, length: 3))
163-
XCTAssertEqual(classif[4].kind, .none)
164-
XCTAssertEqual(classif[4].range, ByteSourceRange(offset: 11, length: 1))
165-
XCTAssertEqual(classif[5].kind, .integerLiteral)
166-
XCTAssertEqual(classif[5].range, ByteSourceRange(offset: 13, length: 1))
167-
XCTAssertEqual(classif[6].kind, .operatorIdentifier)
168-
XCTAssertEqual(classif[6].range, ByteSourceRange(offset: 15, length: 1))
169-
XCTAssertEqual(classif[7].kind, .integerLiteral)
170-
XCTAssertEqual(classif[7].range, ByteSourceRange(offset: 17, length: 1))
171-
XCTAssertEqual(classif[8].kind, .operatorIdentifier)
172-
XCTAssertEqual(classif[8].range, ByteSourceRange(offset: 19, length: 1))
173-
XCTAssertEqual(classif[9].kind, .integerLiteral)
174-
XCTAssertEqual(classif[9].range, ByteSourceRange(offset: 21, length: 1))
175-
XCTAssertEqual(classif[10].kind, .none)
176-
XCTAssertEqual(classif[10].range, ByteSourceRange(offset: 22, length: 0))
177-
}
178-
179-
do {
180-
let source = "infix operator *--*"
181-
let tree = Parser.parse(source: source)
94+
assertClassification(
95+
"""
96+
let x: Int = 4 + 5 / 6
97+
""",
98+
expected: [
99+
ClassificationSpec(source: "let", kind: .keyword),
100+
ClassificationSpec(source: "x", kind: .identifier),
101+
ClassificationSpec(source: "Int", kind: .typeIdentifier),
102+
ClassificationSpec(source: "4", kind: .integerLiteral),
103+
ClassificationSpec(source: "+", kind: .operatorIdentifier),
104+
ClassificationSpec(source: "5", kind: .integerLiteral),
105+
ClassificationSpec(source: "/", kind: .operatorIdentifier),
106+
ClassificationSpec(source: "6", kind: .integerLiteral),
107+
]
108+
)
182109

183-
let tokens = Array(tree.tokens(viewMode: .sourceAccurate))
184-
XCTAssertEqual(tokens.count, 4)
185-
guard tokens.count == 4 else {
186-
return
187-
}
188-
let classif = tokens.map { $0.tokenClassification }
189-
XCTAssertEqual(classif[0].kind, .keyword)
190-
XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 5))
191-
XCTAssertEqual(classif[1].kind, .keyword)
192-
XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 6, length: 8))
193-
XCTAssertEqual(classif[2].kind, .operatorIdentifier)
194-
XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 15, length: 4))
195-
XCTAssertEqual(classif[3].kind, .none)
196-
XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 19, length: 0))
197-
}
110+
assertClassification(
111+
"infix operator *--*",
112+
expected: [
113+
ClassificationSpec(source: "infix", kind: .keyword),
114+
ClassificationSpec(source: "operator", kind: .keyword),
115+
ClassificationSpec(source: "*--*", kind: .operatorIdentifier),
116+
]
117+
)
198118
}
199119
}

0 commit comments

Comments
 (0)