SourceLocation: refactor user-facing part of SourceLocation out and allow it to be computed on demand.

Always computing the user-facing part of source location (line/column) can be
inefficient and unnecessary. This patch refactors the user-facing
part of SourceLocation to a separate data structure and allows it to
be computed on demand.

Author: nkcsgexi

Sources/SwiftSyntax/PrintingDiagnosticConsumer.swift

@@ -38,7 +38,7 @@ public class PrintingDiagnosticConsumer: DiagnosticConsumer {
   /// Prints each of the fields in a diagnositic to stderr.
   public func write(_ diagnostic: Diagnostic) {
     if let loc = diagnostic.location {
-      write("\(loc.file):\(loc.line):\(loc.column): ")
+      write("\(loc.file!):\(loc.line!):\(loc.column!): ")
     } else {
       write("<unknown>:0:0: ")
     }

Sources/SwiftSyntax/SourceLocation.swift

@@ -10,26 +10,75 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Represents a source location in a Swift file.
-public struct SourceLocation: Codable {
+/// Represent the user-facing part of SourceLocation that can be calculated
+/// on demand.
+struct ComputedLocation: Codable {
   /// The line in the file where this location resides. 1-based.
-  public let line: Int
+  let line: Int
 
   /// The UTF-8 byte offset from the beginning of the line where this location
   /// resides. 1-based.
-  public let column: Int
+  let column: Int
+
+  /// The file in which this location resides.
+  let file: String
+
+  init(line: Int, column: Int, file: String) {
+    self.line = line
+    self.column = column
+    self.file = file
+  }
+  init(offset: Int, using converter: SourceLocationConverter) {
+    let loc = converter.location(for: AbsolutePosition(utf8Offset: offset))
+    assert(loc.offset == offset)
+    self.line = loc.line!
+    self.column = loc.column!
+    self.file = loc.file!
+  }
+}
+
+/// Represents a source location in a Swift file.
+public struct SourceLocation: Codable {
+
+  /// Line and column that can be computed on demand.
+  private var compLoc: ComputedLocation?
 
   /// The UTF-8 byte offset into the file where this location resides.
   public let offset: Int
 
+  /// The line in the file where this location resides. 1-based.
+  public var line: Int? {
+    return compLoc?.line
+  }
+
+  /// The UTF-8 byte offset from the beginning of the line where this location
+  /// resides. 1-based.
+  public var column: Int? {
+    return compLoc?.column
+  }
+
   /// The file in which this location resides.
-  public let file: String
+  public var file: String? {
+    return compLoc?.file
+  }
 
   public init(line: Int, column: Int, offset: Int, file: String) {
-    self.line = line
-    self.column = column
     self.offset = offset
-    self.file = file
+    self.compLoc = ComputedLocation(line: line, column: column, file: file)
+  }
+
+  /// Initialize SourceLocation with a utf8 offset. Line, column and file will
+  /// be nil after invoking this initializer. Client can call computeLineColumn(using)
+  /// later to populate these fields.
+  public init(offset: Int) {
+    self.offset = offset
+  }
+
+  /// Populate line, column and file by using a SourceLocationConverter.
+  /// It will assert if these fileds have already been populated.
+  public mutating func computeLineColumn(using converter: SourceLocationConverter) {
+    assert(compLoc == nil, "line and column have already been calculated")
+    self.compLoc = ComputedLocation(offset: offset, using: converter)
   }
 }
 

Tests/SwiftSyntaxTest/AbsolutePosition.swift

@@ -149,15 +149,15 @@ public class AbsolutePositionTestCase: XCTestCase {
     let startLoc = secondReturnStmt.startLocation(converter: converter)
     XCTAssertEqual(startLoc.line, 8)
     XCTAssertEqual(startLoc.column, 1)
-    XCTAssertEqual(converter.position(ofLine: startLoc.line, column: startLoc.column),
+    XCTAssertEqual(converter.position(ofLine: startLoc.line!, column: startLoc.column!),
       secondReturnStmt.positionAfterSkippingLeadingTrivia)
 
     let startLocBeforeTrivia =
       secondReturnStmt.startLocation(converter: converter,
         afterLeadingTrivia: false)
     XCTAssertEqual(startLocBeforeTrivia.line, 6)
     XCTAssertEqual(startLocBeforeTrivia.column, 1)
-    XCTAssertEqual(converter.position(ofLine: startLocBeforeTrivia.line, column: startLocBeforeTrivia.column),
+    XCTAssertEqual(converter.position(ofLine: startLocBeforeTrivia.line!, column: startLocBeforeTrivia.column!),
       secondReturnStmt.position)
 
     let endLoc = secondReturnStmt.endLocation(converter: converter)
@@ -170,9 +170,9 @@ public class AbsolutePositionTestCase: XCTestCase {
     XCTAssertEqual(endLocAfterTrivia.line, 11)
     XCTAssertEqual(endLocAfterTrivia.column, 1)
 
-    XCTAssertTrue(converter.isValid(line: startLoc.line, column: startLoc.column))
-    XCTAssertFalse(converter.isValid(line: startLoc.line, column: startLoc.column+50))
-    XCTAssertFalse(converter.isValid(line: 0, column: startLoc.column))
+    XCTAssertTrue(converter.isValid(line: startLoc.line!, column: startLoc.column!))
+    XCTAssertFalse(converter.isValid(line: startLoc.line!, column: startLoc.column!+50))
+    XCTAssertFalse(converter.isValid(line: 0, column: startLoc.column!))
     XCTAssertTrue(converter.isValid(position: secondReturnStmt.position))
     XCTAssertFalse(converter.isValid(position: secondReturnStmt.position+SourceLength(utf8Length: 100)))
   }