Manually cherry-pick tests from apple/swift:

572a144 Rename byteOffset to utf8Offset and remote utf16
9323d08 [SwiftSyntax] Add accessors for source locations and test diagnostic emission (#16141)

Author: allevato

Tests/SwiftSyntaxTest/AbsolutePosition.swift

@@ -13,22 +13,22 @@ public class AbsolutePositionTestCase: XCTestCase {
     XCTAssertNoThrow(try {
       let source = try String(contentsOf: getInput("visitor.swift"))
       let parsed = try SourceFileSyntax.parse(getInput("visitor.swift"))
-      XCTAssertEqual(parsed.position.byteOffset, 0)
-      XCTAssertEqual(parsed.eofToken.positionAfterSkippingLeadingTrivia.byteOffset,
-                  source.count)
-      XCTAssertEqual(parsed.position.byteOffset, 0)
-      XCTAssertEqual(parsed.byteSize, source.count)
+      XCTAssertEqual(0, parsed.position.utf8Offset)
+      XCTAssertEqual(source.count,
+        parsed.eofToken.positionAfterSkippingLeadingTrivia.utf8Offset)
+      XCTAssertEqual(0, parsed.position.utf8Offset)
+      XCTAssertEqual(source.count, parsed.byteSize)
     }())
   }
 
   public func testClosure() {
     XCTAssertNoThrow(try {
       let source = try String(contentsOf: getInput("closure.swift"))
       let parsed = try SourceFileSyntax.parse(getInput("closure.swift"))
-      XCTAssertEqual(parsed.eofToken.positionAfterSkippingLeadingTrivia.byteOffset,
-                  source.count)
-      XCTAssertEqual(parsed.position.byteOffset, 0)
-      XCTAssertEqual(parsed.byteSize, source.count)
+      XCTAssertEqual(source.count,
+        parsed.eofToken.positionAfterSkippingLeadingTrivia.utf8Offset)
+      XCTAssertEqual(0, parsed.position.utf8Offset)
+      XCTAssertEqual(source.count, parsed.byteSize)
     }())
   }
 
@@ -37,9 +37,9 @@ public class AbsolutePositionTestCase: XCTestCase {
       let parsed = try SourceFileSyntax.parse(getInput("visitor.swift"))
       let renamed = FuncRenamer().visit(parsed) as! SourceFileSyntax
       let renamedSource = renamed.description
-      XCTAssertEqual(renamed.eofToken.positionAfterSkippingLeadingTrivia.byteOffset,
-                  renamedSource.count)
-      XCTAssertEqual(renamed.byteSize, renamedSource.count)
+      XCTAssertEqual(renamedSource.count,
+        renamed.eofToken.positionAfterSkippingLeadingTrivia.utf8Offset)
+      XCTAssertEqual(renamedSource.count, renamed.byteSize)
     }())
   }
 
@@ -53,8 +53,8 @@ public class AbsolutePositionTestCase: XCTestCase {
           _ = node.positionAfterSkippingLeadingTrivia
         }
         override func visit(_ node: TokenSyntax) {
-          XCTAssertEqual(node.position.byteOffset + node.leadingTrivia.byteSize,
-                      node.positionAfterSkippingLeadingTrivia.byteOffset)
+          XCTAssertEqual(node.positionAfterSkippingLeadingTrivia.utf8Offset,
+            node.position.utf8Offset + node.leadingTrivia.byteSize)
         }
       }
       Visitor().visit(parsed)
@@ -101,13 +101,14 @@ public class AbsolutePositionTestCase: XCTestCase {
   public func testTrivias() {
     let idx = 5
     let root = createSourceFile(idx + 1)
-    XCTAssertEqual(root.leadingTrivia!.count, 3)
-    XCTAssertEqual(root.trailingTrivia!.count, 0)
+    XCTAssertEqual(3, root.leadingTrivia!.count)
+    XCTAssertEqual(0, root.trailingTrivia!.count)
     let state = root.statements[idx]
-    XCTAssertEqual(state.leadingTrivia!.count, 3)
-    XCTAssertEqual(state.trailingTrivia!.count, 1)
-    XCTAssertEqual(state.leadingTrivia!.byteSize + state.trailingTrivia!.byteSize
-      + state.byteSizeAfterTrimmingTrivia, state.byteSize)
+    XCTAssertEqual(3, state.leadingTrivia!.count)
+    XCTAssertEqual(1, state.trailingTrivia!.count)
+    XCTAssertEqual(state.byteSize,
+      state.leadingTrivia!.byteSize + state.trailingTrivia!.byteSize
+        + state.byteSizeAfterTrimmingTrivia)
     XCTAssertFalse(root.statements.isImplicit)
   }
 

Tests/SwiftSyntaxTest/DiagnosticTest.swift

@@ -18,6 +18,13 @@ extension Diagnostic.Message {
   /// Suggestion for the user to explicitly check a value does not equal zero.
   static let checkEqualToZero =
     Diagnostic.Message(.note, "check for explicit equality to '0'")
+
+  static func badFunction(_ name: TokenSyntax) -> Diagnostic.Message {
+    return .init(.error, "bad function '\(name.text)'")
+  }
+  static func endOfFunction(_ name: TokenSyntax) -> Diagnostic.Message {
+    return .init(.warning, "end of function '\(name.text)'")
+  }
 }
 
 public class DiagnosticsTestCase: XCTestCase {
@@ -50,4 +57,38 @@ public class DiagnosticsTestCase: XCTestCase {
     guard let fixIt = note.fixIts.first else { return }
     XCTAssertEqual(fixIt.text, " != 0")
   }
-}
+
+  public func testSourceLocations() {
+    let engine = DiagnosticEngine()
+    engine.addConsumer(PrintingDiagnosticConsumer())
+    let url = getInput("diagnostics.swift")
+
+    class Visitor: SyntaxVisitor {
+      let url: URL
+      let engine: DiagnosticEngine
+      init(url: URL, engine: DiagnosticEngine) {
+        self.url = url
+        self.engine = engine
+      }
+      override func visit(_ function: FunctionDeclSyntax) {
+        let startLoc = function.identifier.startLocation(in: url)
+        let endLoc = function.endLocation(in: url)
+        engine.diagnose(.badFunction(function.identifier), location: startLoc) {
+          $0.highlight(function.identifier.sourceRange(in: self.url))
+        }
+        engine.diagnose(.endOfFunction(function.identifier), location: endLoc)
+      }
+    }
+
+    XCTAssertNoThrow(try {
+      let file = try SourceFileSyntax.parse(url)
+      Visitor(url: url, engine: engine).visit(file)
+    }())
+
+    XCTAssertEqual(6, engine.diagnostics.count)
+    let lines = Set(engine.diagnostics.compactMap { $0.location?.line })
+    XCTAssertEqual([1, 3, 5, 7, 9, 11], lines)
+    let columns = Set(engine.diagnostics.compactMap { $0.location?.column })
+    XCTAssertEqual([6, 2], columns)
+  }
+}

Tests/SwiftSyntaxTest/Inputs/diagnostics.swift

@@ -0,0 +1,11 @@
+func foo() {
+
+}
+
+func bar() {
+
+}
+
+func baz() {
+
+}