Merge pull request swiftlang#67 from akyrtzi/opt-raw-length

Optimize determination of a RawSyntax's SourceLength

Author: akyrtzi

Sources/SwiftSyntax/AbsolutePosition.swift

@@ -11,17 +11,17 @@
 //===----------------------------------------------------------------------===//
 
 /// An absolute position in a source file as text - the absolute utf8Offset from
-/// the start, line, and column.
-public struct AbsolutePosition {
+/// the start of the file.
+public struct AbsolutePosition: Comparable {
   public let utf8Offset: Int
-  public let line: Int
-  public let column: Int
 
-  static let startOfFile = AbsolutePosition(line: 1, column: 1, utf8Offset: 0)
+  static let startOfFile = AbsolutePosition(utf8Offset: 0)
 
-  public init(line: Int, column: Int, utf8Offset: Int) {
-    self.line = line
-    self.column = column
+  public init(utf8Offset: Int) {
     self.utf8Offset = utf8Offset
   }
+
+  public static func <(lhs: AbsolutePosition, rhs: AbsolutePosition) -> Bool {
+    return lhs.utf8Offset < rhs.utf8Offset
+  }
 }

Sources/SwiftSyntax/Diagnostic.swift

@@ -12,50 +12,6 @@
 // This file provides the Diagnostic, Note, and FixIt types.
 //===----------------------------------------------------------------------===//
 
-import Foundation
-
-/// Represents a source location in a Swift file.
-public struct SourceLocation: Codable {
-  /// The line in the file where this location resides.
-  public let line: Int
-
-  /// The UTF-8 byte offset from the beginning of the line where this location
-  /// resides.
-  public let column: Int
-
-  /// The UTF-8 byte offset into the file where this location resides.
-  public let offset: Int
-
-  /// The file in which this location resides.
-  public let file: String
-
-  public init(file: String, position: AbsolutePosition) {
-    self.init(line: position.line, column: position.column,
-              offset: position.utf8Offset, file: file)
-  }
-
-  public init(line: Int, column: Int, offset: Int, file: String) {
-    self.line = line
-    self.column = column
-    self.offset = offset
-    self.file = file
-  }
-}
-
-/// Represents a start and end location in a Swift file.
-public struct SourceRange: Codable {
-  /// The beginning location in the source range.
-  public let start: SourceLocation
-
-  /// The beginning location in the source range.
-  public let end: SourceLocation
-
-  public init(start: SourceLocation, end: SourceLocation) {
-    self.start = start
-    self.end = end
-  }
-}
-
 /// A FixIt represents a change to source code in order to "correct" a
 /// diagnostic.
 public enum FixIt: Codable {

Sources/SwiftSyntax/RawSyntax.swift

@@ -10,8 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
-
 /// Box a value type into a reference type
 class Box<T> {
   let value: T
@@ -34,52 +32,21 @@ fileprivate enum RawSyntaxData {
 /// are immutable and can be freely shared between syntax nodes.
 final class RawSyntax {
   fileprivate let data: RawSyntaxData
+  let totalLength: SourceLength
   let presence: SourcePresence
 
-  var _contentLength = LazyNonThreadSafeCache<Box<SourceLength>>()
-
-  /// The length of this node excluding its leading and trailing trivia
-  var contentLength: SourceLength {
-    return _contentLength.value({
-      if isMissing {
-        return Box(SourceLength.zero)
-      }
-      switch data {
-      case .node(kind: _, layout: let layout):
-        let firstElementIndex = layout.firstIndex(where: { $0 != nil })
-        let lastElementIndex = layout.lastIndex(where: { $0 != nil })
-
-        var contentLength = SourceLength.zero
-        for (offset, element) in layout.enumerated() {
-          guard let element = element else {
-            continue
-          }
-          // Skip the node's leading trivia
-          if offset != firstElementIndex {
-            contentLength += element.leadingTriviaLength
-          }
-          contentLength += element.contentLength
-          // Skip the node's trailing trivia
-          if offset != lastElementIndex {
-            contentLength += element.trailingTriviaLength
-          }
-        }
-        return Box(contentLength)
-      case .token(kind: let kind, leadingTrivia: _, trailingTrivia: _):
-        return Box(SourceLength(of: kind.text))
-      }
-    }).value
-  }
-
-  init(kind: SyntaxKind, layout: [RawSyntax?], presence: SourcePresence) {
+  init(kind: SyntaxKind, layout: [RawSyntax?], length: SourceLength,
+       presence: SourcePresence) {
     self.data = .node(kind: kind, layout: layout)
+    self.totalLength = length
     self.presence = presence
   }
 
   init(kind: TokenKind, leadingTrivia: Trivia, trailingTrivia: Trivia,
-       presence: SourcePresence) {
+       length: SourceLength, presence: SourcePresence) {
     self.data = .token(kind: kind, leadingTrivia: leadingTrivia,
                        trailingTrivia: trailingTrivia)
+    self.totalLength = length
     self.presence = presence
   }
 
@@ -129,7 +96,8 @@ final class RawSyntax {
   /// - Returns: A new RawSyntax `.node` with the provided kind and layout, with
   ///            `.missing` source presence.
   static func missing(_ kind: SyntaxKind) -> RawSyntax {
-    return RawSyntax(kind: kind, layout: [], presence: .missing)
+    return RawSyntax(kind: kind, layout: [], length: SourceLength.zero,
+      presence: .missing)
   }
 
   /// Creates a RawSyntax token that's marked missing in the source with the
@@ -138,7 +106,8 @@ final class RawSyntax {
   /// - Returns: A new RawSyntax `.token` with the provided kind, no
   ///            leading/trailing trivia, and `.missing` source presence.
   static func missingToken(_ kind: TokenKind) -> RawSyntax {
-    return RawSyntax(kind: kind, leadingTrivia: [], trailingTrivia: [], presence: .missing)
+    return RawSyntax(kind: kind, leadingTrivia: [], trailingTrivia: [],
+      length: SourceLength.zero, presence: .missing)
   }
 
   /// Returns a new RawSyntax node with the provided layout instead of the
@@ -149,7 +118,8 @@ final class RawSyntax {
   func replacingLayout(_ newLayout: [RawSyntax?]) -> RawSyntax {
     switch data {
     case let .node(kind, _):
-      return RawSyntax(kind: kind, layout: newLayout, presence: presence)
+      return .createAndCalcLength(kind: kind, layout: newLayout,
+        presence: presence)
     case .token(_, _, _): return self
     }
   }
@@ -251,9 +221,51 @@ extension RawSyntax {
     return trailingTrivia?.sourceLength ?? .zero
   }
 
-  /// The length of this node including all of its trivia
-  var totalLength: SourceLength {
-    return leadingTriviaLength + contentLength + trailingTriviaLength
+  /// The length of this node excluding its leading and trailing trivia.
+  var contentLength: SourceLength {
+    return totalLength - (leadingTriviaLength + trailingTriviaLength)
+  }
+
+  /// Convenience function to create a RawSyntax when its byte length is not
+  /// known in advance, e.g. it is programmatically constructed instead of
+  /// created by the parser.
+  ///
+  /// This is a separate function than in the initializer to make it more
+  /// explicit and visible in the code for the instances where we don't have
+  /// the length of the raw node already available.
+  static func createAndCalcLength(kind: SyntaxKind, layout: [RawSyntax?],
+      presence: SourcePresence) -> RawSyntax {
+    let length: SourceLength
+    if case .missing = presence {
+      length = SourceLength.zero
+    } else {
+      var totalen = SourceLength.zero
+      for child in layout {
+        totalen += child?.totalLength ?? .zero
+      }
+      length = totalen
+    }
+    return .init(kind: kind, layout: layout, length: length, presence: presence)
+  }
+
+  /// Convenience function to create a RawSyntax when its byte length is not
+  /// known in advance, e.g. it is programmatically constructed instead of
+  /// created by the parser.
+  ///
+  /// This is a separate function than in the initializer to make it more
+  /// explicit and visible in the code for the instances where we don't have
+  /// the length of the raw node already available.
+  static func createAndCalcLength(kind: TokenKind, leadingTrivia: Trivia,
+      trailingTrivia: Trivia, presence: SourcePresence) -> RawSyntax {
+    let length: SourceLength
+    if case .missing = presence {
+      length = SourceLength.zero
+    } else {
+      length = kind.sourceLength + leadingTrivia.sourceLength +
+        trailingTrivia.sourceLength
+    }
+    return .init(kind: kind, leadingTrivia: leadingTrivia,
+      trailingTrivia: trailingTrivia, length: length, presence: presence)
   }
 }
 

Sources/SwiftSyntax/SourceLength.swift

@@ -11,64 +11,45 @@
 //===----------------------------------------------------------------------===//
 
 /// The length a syntax node spans in the source code. From any AbsolutePosition
-/// you reach a node's end location by either adding its UTF-8 length or by
-/// inserting `lines` newlines and then moving `columns` columns to the right.
-public struct SourceLength {
-  public let newlines: Int
-  public let columnsAtLastLine: Int
+/// you reach a node's end location by adding its UTF-8 length.
+public struct SourceLength: Comparable {
   public let utf8Length: Int
 
   /// Construct the source length of a given text
   public init(of text: String) {
-    var newlines = 0
-    var columnsAtLastLine = 0
-    var utf8Length = 0
-    for char in text {
-      let charLength = String(char).utf8.count
-      utf8Length += charLength
-      switch char {
-      case "\n", "\r\n", "\r":
-        newlines += 1
-        columnsAtLastLine = 0
-      default:
-        columnsAtLastLine += charLength
-      }
-    }
-    self.newlines = newlines
-    self.columnsAtLastLine = columnsAtLastLine
-    self.utf8Length = utf8Length
+    self.utf8Length = text.utf8.count
   }
 
-  public init(newlines: Int, columnsAtLastLine: Int, utf8Length: Int) {
-    self.newlines = newlines
-    self.columnsAtLastLine = columnsAtLastLine
+  public init(utf8Length: Int) {
     self.utf8Length = utf8Length
   }
 
   /// A zero-length source length
   public static let zero: SourceLength = 
-      SourceLength(newlines: 0, columnsAtLastLine: 0, utf8Length: 0)
+      SourceLength(utf8Length: 0)
+
+  public static func <(lhs: SourceLength, rhs: SourceLength) -> Bool {
+    return lhs.utf8Length < rhs.utf8Length
+  }
 
-  /// Combine the length of two source length. Note that the addition is *not*
-  /// commutative (3 columns + 1 line = 1 line but 1 line + 3 columns = 1 line
-  /// and 3 columns)
+  /// Combine the length of two source length.
   public static func +(lhs: SourceLength, rhs: SourceLength) -> SourceLength {
     let utf8Length = lhs.utf8Length + rhs.utf8Length
-    let newlines = lhs.newlines + rhs.newlines
-    let columnsAtLastLine: Int
-    if rhs.newlines == 0 {
-      columnsAtLastLine = lhs.columnsAtLastLine + rhs.columnsAtLastLine
-    } else {
-      columnsAtLastLine = rhs.columnsAtLastLine
-    }
-    return SourceLength(newlines: newlines, 
-                        columnsAtLastLine: columnsAtLastLine, 
-                        utf8Length: utf8Length)
+    return SourceLength(utf8Length: utf8Length)
   }
 
   public static func +=(lhs: inout SourceLength, rhs: SourceLength) {
     lhs = lhs + rhs
   }
+
+  public static func -(lhs: SourceLength, rhs: SourceLength) -> SourceLength {
+    let utf8Length = lhs.utf8Length - rhs.utf8Length
+    return SourceLength(utf8Length: utf8Length)
+  }
+
+  public static func -=(lhs: inout SourceLength, rhs: SourceLength) {
+    lhs = lhs - rhs
+  }
 }
 
 extension AbsolutePosition {
@@ -77,14 +58,7 @@ extension AbsolutePosition {
   public static func +(lhs: AbsolutePosition, rhs: SourceLength) 
       -> AbsolutePosition {
     let utf8Offset = lhs.utf8Offset + rhs.utf8Length
-    let line = lhs.line + rhs.newlines
-    let column: Int
-    if rhs.newlines == 0 {
-      column = lhs.column + rhs.columnsAtLastLine
-    } else {
-      column = rhs.columnsAtLastLine + 1 // AbsolutePosition has 1-based columns
-    }
-    return AbsolutePosition(line: line, column: column, utf8Offset: utf8Offset)
+    return AbsolutePosition(utf8Offset: utf8Offset)
   }
 
   public static func +=(lhs: inout AbsolutePosition, rhs: SourceLength) {