diff --git a/Sources/Diagnose/SourcekitdRequestCommand.swift b/Sources/Diagnose/SourcekitdRequestCommand.swift
index c4cb8665d..14cabbad4 100644
--- a/Sources/Diagnose/SourcekitdRequestCommand.swift
+++ b/Sources/Diagnose/SourcekitdRequestCommand.swift
@@ -56,10 +56,9 @@ public struct SourceKitdRequestCommand: AsyncParsableCommand {
       let requestInfo = try RequestInfo(request: requestString)
 
       let lineTable = LineTable(requestInfo.fileContents)
-      if let offset = lineTable.utf8OffsetOf(line: line - 1, utf8Column: column - 1) {
-        print("Adjusting request offset to \(offset)")
-        requestString.replace(#/key.offset: [0-9]+/#, with: "key.offset: \(offset)")
-      }
+      let offset = lineTable.utf8OffsetOf(line: line - 1, utf8Column: column - 1)
+      print("Adjusting request offset to \(offset)")
+      requestString.replace(#/key.offset: [0-9]+/#, with: "key.offset: \(offset)")
     }
 
     let request = try requestString.cString(using: .utf8)!.withUnsafeBufferPointer { buffer in
diff --git a/Sources/SKSupport/LineTable.swift b/Sources/SKSupport/LineTable.swift
index 87f00e9f6..343e81f86 100644
--- a/Sources/SKSupport/LineTable.swift
+++ b/Sources/SKSupport/LineTable.swift
@@ -125,15 +125,50 @@ extension LineTable {
   }
 }
 
-// MARK: - Position translation
+// MARK: - Position conversion
 
 extension LineTable {
   // MARK: line:column <-> String.Index
 
+  /// Result of `lineSlice(at:)`
+  @usableFromInline
+  enum LineSliceResult {
+    /// The line index passed to `lineSlice(at:)` was negative.
+    case beforeFirstLine
+    /// The contents of the line at the index passed to `lineSlice(at:)`.
+    case line(Substring)
+    /// The line index passed to `lineSlice(at:)` was after the last line of the file
+    case afterLastLine
+  }
+
+  /// Extracts the contents of the line at the given index.
+  ///
+  /// If `line` is out-of-bounds, logs a fault and returns either `beforeFirstLine` or `afterLastLine`.
+  @usableFromInline
+  func lineSlice(at line: Int, callerFile: StaticString, callerLine: UInt) -> LineSliceResult {
+    guard line >= 0 else {
+      logger.fault(
+        """
+        Line \(line) is negative (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
+        """
+      )
+      return .beforeFirstLine
+    }
+    guard line < count else {
+      logger.fault(
+        """
+        Line \(line) is out-of range (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
+        """
+      )
+      return .afterLastLine
+    }
+    return .line(self[line])
+  }
+
   /// Converts the given UTF-16-based `line:column`` position to a `String.Index`.
   ///
-  /// If the position does not refer to a valid position with in the source file, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the source file, returns the closest valid position and
+  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter line: Line number (zero-based).
   /// - parameter utf16Column: UTF-16 column offset (zero-based).
@@ -143,34 +178,42 @@ extension LineTable {
     utf16Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> String.Index? {
-    guard line < count else {
+  ) -> String.Index {
+    let lineSlice: Substring
+    switch self.lineSlice(at: line, callerFile: callerFile, callerLine: callerLine) {
+    case .beforeFirstLine:
+      return self.content.startIndex
+    case .afterLastLine:
+      return self.content.endIndex
+    case .line(let line):
+      lineSlice = line
+    }
+    guard utf16Column >= 0 else {
       logger.fault(
         """
-        Unable to get string index for \(line):\(utf16Column) (UTF-16) because line is out of range \
+        Column is negative while converting \(line):\(utf16Column) (UTF-16) to String.Index \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return lineSlice.startIndex
     }
-    let lineSlice = self[line]
     guard let index = content.utf16.index(lineSlice.startIndex, offsetBy: utf16Column, limitedBy: lineSlice.endIndex)
     else {
       logger.fault(
         """
-        Unable to get string index for \(line):\(utf16Column) (UTF-16) because column is out of range \
+        Column is past line end while converting \(line):\(utf16Column) (UTF-16) to String.Index \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return lineSlice.endIndex
     }
     return index
   }
 
   /// Converts the given UTF-8-based `line:column`` position to a `String.Index`.
   ///
-  /// If the position does not refer to a valid position with in the source file, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the source file, returns the closest valid position and
+  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter line: Line number (zero-based).
   /// - parameter utf8Column: UTF-8 column offset (zero-based).
@@ -180,35 +223,46 @@ extension LineTable {
     utf8Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> String.Index? {
-    guard 0 <= line, line < count else {
+  ) -> String.Index {
+    let lineSlice: Substring
+    switch self.lineSlice(at: line, callerFile: callerFile, callerLine: callerLine) {
+    case .beforeFirstLine:
+      return self.content.startIndex
+    case .afterLastLine:
+      return self.content.endIndex
+    case .line(let line):
+      lineSlice = line
+    }
+
+    guard utf8Column >= 0 else {
       logger.fault(
         """
-        Unable to get string index for \(line):\(utf8Column) (UTF-8) because line is out of range \
+        Column is negative while converting \(line):\(utf8Column) (UTF-8) to String.Index. \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return lineSlice.startIndex
     }
-    guard 0 <= utf8Column else {
+    guard let index = content.utf8.index(lineSlice.startIndex, offsetBy: utf8Column, limitedBy: lineSlice.endIndex)
+    else {
       logger.fault(
         """
-        Unable to get string index for \(line):\(utf8Column) (UTF-8) because column is out of range \
+        Column is after end of line while converting \(line):\(utf8Column) (UTF-8) to String.Index. \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return lineSlice.endIndex
     }
-    let lineSlice = self[line]
-    return content.utf8.index(lineSlice.startIndex, offsetBy: utf8Column, limitedBy: lineSlice.endIndex)
+
+    return index
   }
 
   // MARK: line:column <-> UTF-8 offset
 
   /// Converts the given UTF-16-based `line:column`` position to a UTF-8 offset within the source file.
   ///
-  /// If the position does not refer to a valid position with in the source file, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the source file, returns the closest valid offset and
+  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter line: Line number (zero-based).
   /// - parameter utf16Column: UTF-16 column offset (zero-based).
@@ -218,24 +272,20 @@ extension LineTable {
     utf16Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Int? {
-    guard
-      let stringIndex = stringIndexOf(
-        line: line,
-        utf16Column: utf16Column,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
+  ) -> Int {
+    let stringIndex = stringIndexOf(
+      line: line,
+      utf16Column: utf16Column,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
     return content.utf8.distance(from: content.startIndex, to: stringIndex)
   }
 
-  /// Converts the given UTF-8-based `line:column`` position to a UTF-8 offset within the source file.
+  /// Converts the given UTF-8-based `line:column` position to a UTF-8 offset within the source file.
   ///
-  /// If the position does not refer to a valid position with in the source file, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the source file, returns the closest valid offset and
+  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter line: Line number (zero-based).
   /// - parameter utf8Column: UTF-8 column offset (zero-based).
@@ -245,24 +295,20 @@ extension LineTable {
     utf8Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Int? {
-    guard
-      let stringIndex = stringIndexOf(
-        line: line,
-        utf8Column: utf8Column,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
+  ) -> Int {
+    let stringIndex = stringIndexOf(
+      line: line,
+      utf8Column: utf8Column,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
     return content.utf8.distance(from: content.startIndex, to: stringIndex)
   }
 
-  /// Converts the given UTF-16-based line:column position to the UTF-8 offset of that position within the source file.
+  /// Converts the given UTF-8 offset to a zero-based UTF-16 line:column pair.
   ///
-  /// If the position does not refer to a valid position with in the snapshot, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the snapshot, returns the closest valid line:column
+  /// pair and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter utf8Offset: UTF-8 buffer offset (zero-based).
   @inlinable
@@ -270,47 +316,48 @@ extension LineTable {
     utf8Offset: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> (line: Int, utf16Column: Int)? {
+  ) -> (line: Int, utf16Column: Int) {
+    guard utf8Offset >= 0 else {
+      logger.fault(
+        """
+        UTF-8 offset \(utf8Offset) is negative while converting it to UTF-16 line:column \
+        (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
+        """
+      )
+      return (line: 0, utf16Column: 0)
+    }
     guard utf8Offset <= content.utf8.count else {
       logger.fault(
         """
-        Unable to get line and UTF-16 column for UTF-8 offset \(utf8Offset) because offset is out of range \
+        UTF-8 offset \(utf8Offset) is past the end of the file while converting it to UTF-16 line:column \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return lineAndUTF16ColumnOf(content.endIndex)
     }
     return lineAndUTF16ColumnOf(content.utf8.index(content.startIndex, offsetBy: utf8Offset))
   }
 
   /// Converts the given UTF-8-based line:column position to the UTF-8 offset of that position within the source file.
   ///
-  /// If the position does not refer to a valid position with in the snapshot, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the snapshot, returns the closest valid line:colum pair
+  /// and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   @inlinable func lineAndUTF8ColumnOf(
     utf8Offset: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> (line: Int, utf8Column: Int)? {
-    guard
-      let (line, utf16Column) = lineAndUTF16ColumnOf(
-        utf8Offset: utf8Offset,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
-    guard
-      let utf8Column = utf8ColumnAt(
-        line: line,
-        utf16Column: utf16Column,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
+  ) -> (line: Int, utf8Column: Int) {
+    let (line, utf16Column) = lineAndUTF16ColumnOf(
+      utf8Offset: utf8Offset,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
+    let utf8Column = utf8ColumnAt(
+      line: line,
+      utf16Column: utf16Column,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
     return (line, utf8Column)
   }
 
@@ -318,8 +365,8 @@ extension LineTable {
 
   /// Returns UTF-16 column offset at UTF-8 based `line:column` position.
   ///
-  /// If the position does not refer to a valid position with in the snapshot, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the snapshot, performs a best-effort recovery and logs
+  /// a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter line: Line number (zero-based).
   /// - parameter utf8Column: UTF-8 column offset (zero-based).
@@ -329,21 +376,34 @@ extension LineTable {
     utf8Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Int? {
-    return convertColumn(
-      line: line,
-      column: utf8Column,
-      indexFunction: content.utf8.index(_:offsetBy:limitedBy:),
-      distanceFunction: content.utf16.distance(from:to:),
-      callerFile: callerFile,
-      callerLine: callerLine
-    )
+  ) -> Int {
+    let lineSlice: Substring
+    switch self.lineSlice(at: line, callerFile: callerFile, callerLine: callerLine) {
+    case .beforeFirstLine, .afterLastLine:
+      // This line is out-of-bounds. `lineSlice(at:)` already logged a fault.
+      // Recovery by assuming that UTF-8 and UTF-16 columns are similar.
+      return utf8Column
+    case .line(let line):
+      lineSlice = line
+    }
+    guard
+      let stringIndex = lineSlice.utf8.index(lineSlice.startIndex, offsetBy: utf8Column, limitedBy: lineSlice.endIndex)
+    else {
+      logger.fault(
+        """
+        UTF-8 column is past the end of the line while getting UTF-16 column of \(line):\(utf8Column) \
+        (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
+        """
+      )
+      return lineSlice.utf16.count
+    }
+    return lineSlice.utf16.distance(from: lineSlice.startIndex, to: stringIndex)
   }
 
   /// Returns UTF-8 column offset at UTF-16 based `line:column` position.
   ///
-  /// If the position does not refer to a valid position with in the snapshot, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the position does not refer to a valid position with in the snapshot, performs a bets-effort recovery and logs
+  /// a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   ///
   /// - parameter line: Line number (zero-based).
   /// - parameter utf16Column: UTF-16 column offset (zero-based).
@@ -353,45 +413,31 @@ extension LineTable {
     utf16Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Int? {
-    return convertColumn(
-      line: line,
-      column: utf16Column,
-      indexFunction: content.utf16.index(_:offsetBy:limitedBy:),
-      distanceFunction: content.utf8.distance(from:to:),
-      callerFile: callerFile,
-      callerLine: callerLine
-    )
-  }
-
-  @inlinable
-  func convertColumn(
-    line: Int,
-    column: Int,
-    indexFunction: (Substring.Index, Int, Substring.Index) -> Substring.Index?,
-    distanceFunction: (Substring.Index, Substring.Index) -> Int,
-    callerFile: StaticString = #fileID,
-    callerLine: UInt = #line
-  ) -> Int? {
-    guard line < count else {
-      logger.fault(
-        """
-        Unable to convert column of \(line):\(column) because line is out of range \
-        (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
-        """
-      )
-      return nil
+  ) -> Int {
+    let lineSlice: Substring
+    switch self.lineSlice(at: line, callerFile: callerFile, callerLine: callerLine) {
+    case .beforeFirstLine, .afterLastLine:
+      // This line is out-of-bounds. `lineSlice` already logged a fault.
+      // Recovery by assuming that UTF-8 and UTF-16 columns are similar.
+      return utf16Column
+    case .line(let line):
+      lineSlice = line
     }
-    let lineSlice = self[line]
-    guard let targetIndex = indexFunction(lineSlice.startIndex, column, lineSlice.endIndex) else {
+    guard
+      let stringIndex = lineSlice.utf16.index(
+        lineSlice.startIndex,
+        offsetBy: utf16Column,
+        limitedBy: lineSlice.endIndex
+      )
+    else {
       logger.fault(
         """
-        Unable to convert column of \(line):\(column) because column is out of range \
+        UTF-16 column is past the end of the line while getting UTF-8 column of \(line):\(utf16Column) \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return lineSlice.utf8.count
     }
-    return distanceFunction(lineSlice.startIndex, targetIndex)
+    return lineSlice.utf8.distance(from: lineSlice.startIndex, to: stringIndex)
   }
 }
diff --git a/Sources/SKTestSupport/TestSourceKitLSPClient.swift b/Sources/SKTestSupport/TestSourceKitLSPClient.swift
index d3ce52091..72fe9107d 100644
--- a/Sources/SKTestSupport/TestSourceKitLSPClient.swift
+++ b/Sources/SKTestSupport/TestSourceKitLSPClient.swift
@@ -357,9 +357,7 @@ public struct DocumentPositions {
 
     let lineTable = LineTable(textWithoutMarkers)
     positions = markers.mapValues { offset in
-      guard let (line, column) = lineTable.lineAndUTF16ColumnOf(utf8Offset: offset) else {
-        preconditionFailure("UTF-8 offset not within source file: \(offset)")
-      }
+      let (line, column) = lineTable.lineAndUTF16ColumnOf(utf8Offset: offset)
       return Position(line: line, utf16index: column)
     }
   }
diff --git a/Sources/SourceKitLSP/DocumentManager.swift b/Sources/SourceKitLSP/DocumentManager.swift
index 67d188eda..2cf11ef78 100644
--- a/Sources/SourceKitLSP/DocumentManager.swift
+++ b/Sources/SourceKitLSP/DocumentManager.swift
@@ -88,7 +88,6 @@ public final class DocumentManager {
   public enum Error: Swift.Error {
     case alreadyOpen(DocumentURI)
     case missingDocument(DocumentURI)
-    case failedToConvertPosition
   }
 
   let queue: DispatchQueue = DispatchQueue(label: "document-manager-queue")
@@ -156,10 +155,7 @@ public final class DocumentManager {
 
       var sourceEdits: [SourceEdit] = []
       for edit in edits {
-        guard let sourceEdit = SourceEdit(edit: edit, lineTableBeforeEdit: document.latestLineTable) else {
-          throw Error.failedToConvertPosition
-        }
-        sourceEdits.append(sourceEdit)
+        sourceEdits.append(SourceEdit(edit: edit, lineTableBeforeEdit: document.latestLineTable))
 
         if let range = edit.range {
           document.latestLineTable.replace(
@@ -234,20 +230,16 @@ fileprivate extension SourceEdit {
   ///
   /// Returns `nil` if the `TextDocumentContentChangeEvent` refers to line:column positions that don't exist in
   /// `LineTable`.
-  init?(edit: TextDocumentContentChangeEvent, lineTableBeforeEdit: LineTable) {
+  init(edit: TextDocumentContentChangeEvent, lineTableBeforeEdit: LineTable) {
     if let range = edit.range {
-      guard
-        let offset = lineTableBeforeEdit.utf8OffsetOf(
-          line: range.lowerBound.line,
-          utf16Column: range.lowerBound.utf16index
-        ),
-        let end = lineTableBeforeEdit.utf8OffsetOf(
-          line: range.upperBound.line,
-          utf16Column: range.upperBound.utf16index
-        )
-      else {
-        return nil
-      }
+      let offset = lineTableBeforeEdit.utf8OffsetOf(
+        line: range.lowerBound.line,
+        utf16Column: range.lowerBound.utf16index
+      )
+      let end = lineTableBeforeEdit.utf8OffsetOf(
+        line: range.upperBound.line,
+        utf16Column: range.upperBound.utf16index
+      )
       self.init(
         range: AbsolutePosition(utf8Offset: offset)..<AbsolutePosition(utf8Offset: end),
         replacement: edit.text
diff --git a/Sources/SourceKitLSP/Rename.swift b/Sources/SourceKitLSP/Rename.swift
index eec33a699..43c6be799 100644
--- a/Sources/SourceKitLSP/Rename.swift
+++ b/Sources/SourceKitLSP/Rename.swift
@@ -186,12 +186,8 @@ fileprivate struct SyntacticRenamePiece {
     else {
       return nil
     }
-    guard
-      let start = snapshot.positionOf(zeroBasedLine: line - 1, utf8Column: column - 1),
-      let end = snapshot.positionOf(zeroBasedLine: endLine - 1, utf8Column: endColumn - 1)
-    else {
-      return nil
-    }
+    let start = snapshot.positionOf(zeroBasedLine: line - 1, utf8Column: column - 1)
+    let end = snapshot.positionOf(zeroBasedLine: endLine - 1, utf8Column: endColumn - 1)
     guard let kind = SyntacticRenamePieceKind(kind, values: values) else {
       return nil
     }
@@ -270,23 +266,19 @@ private extension LineTable {
   ///
   /// If either the lower or upper bound of `range` do not refer to valid positions with in the snapshot, returns
   /// `nil` and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
-  subscript(range: Range<Position>, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> Substring? {
-    guard
-      let start = self.stringIndexOf(
-        line: range.lowerBound.line,
-        utf16Column: range.lowerBound.utf16index,
-        callerFile: callerFile,
-        callerLine: callerLine
-      ),
-      let end = self.stringIndexOf(
-        line: range.upperBound.line,
-        utf16Column: range.upperBound.utf16index,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
+  subscript(range: Range<Position>, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> Substring {
+    let start = self.stringIndexOf(
+      line: range.lowerBound.line,
+      utf16Column: range.lowerBound.utf16index,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
+    let end = self.stringIndexOf(
+      line: range.upperBound.line,
+      utf16Column: range.upperBound.utf16index,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
     return self.content[start..<end]
   }
 }
@@ -327,14 +319,11 @@ private extension IndexSymbolKind {
 
 extension SwiftLanguageService {
   enum NameTranslationError: Error, CustomStringConvertible {
-    case cannotComputeOffset(SymbolLocation)
     case malformedSwiftToClangTranslateNameResponse(SKDResponseDictionary)
     case malformedClangToSwiftTranslateNameResponse(SKDResponseDictionary)
 
     var description: String {
       switch self {
-      case .cannotComputeOffset(let position):
-        return "Failed to determine UTF-8 offset of \(position)"
       case .malformedSwiftToClangTranslateNameResponse(let response):
         return """
           Malformed response for Swift to Clang name translation
@@ -369,18 +358,11 @@ extension SwiftLanguageService {
       throw ResponseError.unknown("Failed to get contents of \(uri.forLogging) to translate Swift name to clang name")
     }
 
-    guard
-      let position = snapshot.position(of: symbolLocation),
-      let offset = snapshot.utf8Offset(of: position)
-    else {
-      throw NameTranslationError.cannotComputeOffset(symbolLocation)
-    }
-
     let req = sourcekitd.dictionary([
       keys.request: sourcekitd.requests.nameTranslation,
       keys.sourceFile: snapshot.uri.pseudoPath,
       keys.compilerArgs: await self.buildSettings(for: snapshot.uri)?.compilerArgs as [SKDRequestValue]?,
-      keys.offset: offset,
+      keys.offset: snapshot.utf8Offset(of: snapshot.position(of: symbolLocation)),
       keys.nameKind: sourcekitd.values.nameSwift,
       keys.baseName: name.baseName,
       keys.argNames: sourcekitd.array(name.parameters.map { $0.stringOrWildcard }),
@@ -427,17 +409,11 @@ extension SwiftLanguageService {
     isObjectiveCSelector: Bool,
     name: String
   ) async throws -> String {
-    guard
-      let position = snapshot.position(of: symbolLocation),
-      let offset = snapshot.utf8Offset(of: position)
-    else {
-      throw NameTranslationError.cannotComputeOffset(symbolLocation)
-    }
     let req = sourcekitd.dictionary([
       keys.request: sourcekitd.requests.nameTranslation,
       keys.sourceFile: snapshot.uri.pseudoPath,
       keys.compilerArgs: await self.buildSettings(for: snapshot.uri)?.compilerArgs as [SKDRequestValue]?,
-      keys.offset: offset,
+      keys.offset: snapshot.utf8Offset(of: snapshot.position(of: symbolLocation)),
       keys.nameKind: sourcekitd.values.nameObjc,
     ])
 
@@ -947,10 +923,7 @@ extension SwiftLanguageService {
   /// also be a closing ']' for subscripts or the end of a trailing closure.
   private func findFunctionLikeRange(of position: Position, in snapshot: DocumentSnapshot) async -> Range<Position>? {
     let tree = await self.syntaxTreeManager.syntaxTree(for: snapshot)
-    guard let absolutePosition = snapshot.absolutePosition(of: position) else {
-      return nil
-    }
-    guard let token = tree.token(at: absolutePosition) else {
+    guard let token = tree.token(at: snapshot.absolutePosition(of: position)) else {
       return nil
     }
 
@@ -1018,11 +991,10 @@ extension SwiftLanguageService {
       break
     }
 
-    if let startToken, let endToken,
-      let startPosition = snapshot.position(of: startToken.positionAfterSkippingLeadingTrivia),
-      let endPosition = snapshot.position(of: endToken.endPositionBeforeTrailingTrivia)
-    {
-      return startPosition..<endPosition
+    if let startToken, let endToken {
+      return snapshot.range(
+        of: startToken.positionAfterSkippingLeadingTrivia..<endToken.endPositionBeforeTrailingTrivia
+      )
     }
     return nil
   }
@@ -1130,9 +1102,7 @@ extension SwiftLanguageService {
     renameLocation: RenameLocation,
     newName: CrossLanguageName
   ) async -> [TextEdit] {
-    guard let position = snapshot.absolutePosition(of: renameLocation) else {
-      return []
-    }
+    let position = snapshot.absolutePosition(of: renameLocation)
     let syntaxTree = await syntaxTreeManager.syntaxTree(for: snapshot)
     let token = syntaxTree.token(at: position)
     let parameterClause: FunctionParameterClauseSyntax?
@@ -1192,11 +1162,8 @@ extension SwiftLanguageService {
         definitionLanguage: .swift
       )
 
-      guard let parameterPosition = snapshot.position(of: parameter.positionAfterSkippingLeadingTrivia) else {
-        continue
-      }
-
       let parameterRenameEdits = await orLog("Renaming parameter") {
+        let parameterPosition = snapshot.position(of: parameter.positionAfterSkippingLeadingTrivia)
         // Once we have lexical scope lookup in swift-syntax, this can be a purely syntactic rename.
         // We know that the parameters are variables and thus there can't be overloads that need to be resolved by the
         // type checker.
@@ -1247,9 +1214,9 @@ extension SwiftLanguageService {
         // E.g. `func foo(a: Int)` becomes `func foo(_ a: Int)`.
         return TextEdit(range: piece.range, newText: " " + oldParameterName)
       }
-      if let original = snapshot.lineTable[piece.range],
-        case .named(let newParameterLabel) = newParameter,
-        newParameterLabel.trimmingCharacters(in: .whitespaces) == original.trimmingCharacters(in: .whitespaces)
+      if case .named(let newParameterLabel) = newParameter,
+        newParameterLabel.trimmingCharacters(in: .whitespaces)
+          == snapshot.lineTable[piece.range].trimmingCharacters(in: .whitespaces)
       {
         // We are changing the external parameter name to be the same one as the internal parameter name. The
         // internal name is thus no longer needed. Drop it.
@@ -1336,17 +1303,18 @@ extension SwiftLanguageService {
       }
       return compoundRenameRange.pieces.compactMap { (piece) -> TextEdit? in
         if piece.kind == .baseName {
-          if let absolutePiecePosition = snapshot.absolutePosition(of: piece.range.lowerBound),
-            let firstNameToken = tree.token(at: absolutePiecePosition),
+          if let firstNameToken = tree.token(at: snapshot.absolutePosition(of: piece.range.lowerBound)),
             firstNameToken.keyPathInParent == \FunctionParameterSyntax.firstName,
             let parameterSyntax = firstNameToken.parent(as: FunctionParameterSyntax.self),
-            parameterSyntax.secondName == nil,  // Should always be true because otherwise decl would be second name
-            let firstNameEndPos = snapshot.position(of: firstNameToken.endPositionBeforeTrailingTrivia)
+            parameterSyntax.secondName == nil  // Should always be true because otherwise decl would be second name
           {
             // We are renaming a function parameter from inside the function body.
             // This should be a local rename and it shouldn't affect all the callers of the function. Introduce the new
             // name as a second name.
-            return TextEdit(range: firstNameEndPos..<firstNameEndPos, newText: " " + newName.baseName)
+            return TextEdit(
+              range: Range(snapshot.position(of: firstNameToken.endPositionBeforeTrailingTrivia)),
+              newText: " " + newName.baseName
+            )
           }
 
           return TextEdit(range: piece.range, newText: newName.baseName)
@@ -1479,13 +1447,10 @@ fileprivate extension SyntaxProtocol {
 
 fileprivate extension RelatedIdentifiersResponse {
   func renameLocations(in snapshot: DocumentSnapshot) -> [RenameLocation] {
-    return self.relatedIdentifiers.compactMap {
-      (relatedIdentifier) -> RenameLocation? in
+    return self.relatedIdentifiers.map {
+      (relatedIdentifier) -> RenameLocation in
       let position = relatedIdentifier.range.lowerBound
-      guard let utf8Column = snapshot.lineTable.utf8ColumnAt(line: position.line, utf16Column: position.utf16index)
-      else {
-        return nil
-      }
+      let utf8Column = snapshot.lineTable.utf8ColumnAt(line: position.line, utf16Column: position.utf16index)
       return RenameLocation(line: position.line + 1, utf8Column: utf8Column + 1, usage: relatedIdentifier.usage)
     }
   }
diff --git a/Sources/SourceKitLSP/Swift/AdjustPositionToStartOfIdentifier.swift b/Sources/SourceKitLSP/Swift/AdjustPositionToStartOfIdentifier.swift
index 209f6a748..f77e6ec4c 100644
--- a/Sources/SourceKitLSP/Swift/AdjustPositionToStartOfIdentifier.swift
+++ b/Sources/SourceKitLSP/Swift/AdjustPositionToStartOfIdentifier.swift
@@ -53,10 +53,7 @@ extension SwiftLanguageService {
     in snapshot: DocumentSnapshot
   ) async -> Position {
     let tree = await self.syntaxTreeManager.syntaxTree(for: snapshot)
-    guard let swiftSyntaxPosition = snapshot.absolutePosition(of: position) else {
-      return position
-    }
-    let visitor = StartOfIdentifierFinder(position: swiftSyntaxPosition)
+    let visitor = StartOfIdentifierFinder(position: snapshot.absolutePosition(of: position))
     visitor.walk(tree)
     if let resolvedPosition = visitor.resolvedPosition {
       return snapshot.position(of: resolvedPosition) ?? position
diff --git a/Sources/SourceKitLSP/Swift/CodeCompletion.swift b/Sources/SourceKitLSP/Swift/CodeCompletion.swift
index 3d913a2e4..fae12340c 100644
--- a/Sources/SourceKitLSP/Swift/CodeCompletion.swift
+++ b/Sources/SourceKitLSP/Swift/CodeCompletion.swift
@@ -21,21 +21,11 @@ extension SwiftLanguageService {
     let snapshot = try documentManager.latestSnapshot(req.textDocument.uri)
 
     let completionPos = await adjustPositionToStartOfIdentifier(req.position, in: snapshot)
-
-    guard let offset = snapshot.utf8Offset(of: completionPos) else {
-      return CompletionList(isIncomplete: true, items: [])
-    }
+    let offset = snapshot.utf8Offset(of: completionPos)
+    let filterText = String(snapshot.text[snapshot.indexOf(utf8Offset: offset)..<snapshot.index(of: req.position)])
 
     let options = req.sourcekitlspOptions ?? serverOptions.completionOptions
 
-    guard let start = snapshot.indexOf(utf8Offset: offset),
-      let end = snapshot.index(of: req.position)
-    else {
-      return CompletionList(isIncomplete: true, items: [])
-    }
-
-    let filterText = String(snapshot.text[start..<end])
-
     let clientSupportsSnippets =
       capabilityRegistry.clientCapabilities.textDocument?.completion?.completionItem?.snippetSupport ?? false
     let buildSettings = await buildSettings(for: snapshot.uri)
diff --git a/Sources/SourceKitLSP/Swift/CodeCompletionSession.swift b/Sources/SourceKitLSP/Swift/CodeCompletionSession.swift
index 0f1e7314c..97f22b645 100644
--- a/Sources/SourceKitLSP/Swift/CodeCompletionSession.swift
+++ b/Sources/SourceKitLSP/Swift/CodeCompletionSession.swift
@@ -365,17 +365,13 @@ class CodeCompletionSession {
 
       let textEdit: TextEdit?
       if let text = text {
-        guard
-          let edit = self.computeCompletionTextEdit(
-            completionPos: completionPos,
-            requestPosition: requestPosition,
-            utf8CodeUnitsToErase: utf8CodeUnitsToErase,
-            newText: text,
-            snapshot: snapshot
-          )
-        else {
-          return true  // continue
-        }
+        let edit = self.computeCompletionTextEdit(
+          completionPos: completionPos,
+          requestPosition: requestPosition,
+          utf8CodeUnitsToErase: utf8CodeUnitsToErase,
+          newText: text,
+          snapshot: snapshot
+        )
         textEdit = edit
 
         if utf8CodeUnitsToErase != 0, filterName != nil, let textEdit = textEdit {
@@ -383,19 +379,7 @@ class CodeCompletionSession {
           // we need to prepend the deleted text to filterText.
           // This also works around a behaviour in VS Code that causes completions to not show up
           // if a '.' is being replaced for Optional completion.
-          guard
-            let startIndex = snapshot.lineTable.stringIndexOf(
-              line: textEdit.range.lowerBound.line,
-              utf16Column: textEdit.range.lowerBound.utf16index
-            ),
-            let endIndex = snapshot.lineTable.stringIndexOf(
-              line: completionPos.line,
-              utf16Column: completionPos.utf16index
-            )
-          else {
-            return true  // continue
-          }
-          let filterPrefix = snapshot.text[startIndex..<endIndex]
+          let filterPrefix = snapshot.text[snapshot.indexRange(of: textEdit.range.lowerBound..<completionPos)]
           filterName = filterPrefix + filterName!
         }
       } else {
@@ -433,7 +417,7 @@ class CodeCompletionSession {
     utf8CodeUnitsToErase: Int,
     newText: String,
     snapshot: DocumentSnapshot
-  ) -> TextEdit? {
+  ) -> TextEdit {
     let textEditRangeStart: Position
 
     // Compute the TextEdit
@@ -456,15 +440,7 @@ class CodeCompletionSession {
       assert(completionPos.line == requestPosition.line)
       // Construct a string index for the edit range start by subtracting the UTF-8 code units to erase from the completion position.
       let line = snapshot.lineTable[completionPos.line]
-      guard
-        let completionPosStringIndex = snapshot.lineTable.stringIndexOf(
-          line: completionPos.line,
-          utf16Column: completionPos.utf16index
-        )
-      else {
-        return nil
-      }
-      let deletionStartStringIndex = line.utf8.index(completionPosStringIndex, offsetBy: -utf8CodeUnitsToErase)
+      let deletionStartStringIndex = line.utf8.index(snapshot.index(of: completionPos), offsetBy: -utf8CodeUnitsToErase)
 
       // Compute the UTF-16 offset of the deletion start range. If the start lies in a previous line, this will be negative
       let deletionStartUtf16Offset = line.utf16.distance(from: line.startIndex, to: deletionStartStringIndex)
diff --git a/Sources/SourceKitLSP/Swift/CursorInfo.swift b/Sources/SourceKitLSP/Swift/CursorInfo.swift
index a76f43677..e0f75b1d7 100644
--- a/Sources/SourceKitLSP/Swift/CursorInfo.swift
+++ b/Sources/SourceKitLSP/Swift/CursorInfo.swift
@@ -132,9 +132,7 @@ extension SwiftLanguageService {
   ) async throws -> (cursorInfo: [CursorInfo], refactorActions: [SemanticRefactorCommand]) {
     let snapshot = try documentManager.latestSnapshot(uri)
 
-    guard let offsetRange = snapshot.utf8OffsetRange(of: range) else {
-      throw CursorInfoError.invalidRange(range)
-    }
+    let offsetRange = snapshot.utf8OffsetRange(of: range)
 
     let keys = self.keys
 
diff --git a/Sources/SourceKitLSP/Swift/Diagnostic.swift b/Sources/SourceKitLSP/Swift/Diagnostic.swift
index eb0880604..b47e28d5b 100644
--- a/Sources/SourceKitLSP/Swift/Diagnostic.swift
+++ b/Sources/SourceKitLSP/Swift/Diagnostic.swift
@@ -61,12 +61,7 @@ extension CodeAction {
   init?(_ fixIt: FixIt, in snapshot: DocumentSnapshot) {
     var textEdits = [TextEdit]()
     for edit in fixIt.edits {
-      guard let startPosition = snapshot.position(of: edit.range.lowerBound),
-        let endPosition = snapshot.position(of: edit.range.upperBound)
-      else {
-        continue
-      }
-      textEdits.append(TextEdit(range: startPosition..<endPosition, newText: edit.replacement))
+      textEdits.append(TextEdit(range: snapshot.range(of: edit.range), newText: edit.replacement))
     }
 
     self.init(
@@ -81,9 +76,9 @@ extension CodeAction {
     if edits.isEmpty {
       return nil
     }
-    guard let startIndex = snapshot.index(of: edits[0].range.lowerBound),
-      let endIndex = snapshot.index(of: edits[0].range.upperBound),
-      startIndex <= endIndex,
+    let startIndex = snapshot.index(of: edits[0].range.lowerBound)
+    let endIndex = snapshot.index(of: edits[0].range.upperBound)
+    guard startIndex <= endIndex,
       snapshot.text.indices.contains(startIndex),
       endIndex <= snapshot.text.endIndex
     else {
@@ -123,8 +118,6 @@ extension TextEdit {
     if let utf8Offset: Int = fixit[keys.offset],
       let length: Int = fixit[keys.length],
       let replacement: String = fixit[keys.sourceText],
-      let position = snapshot.positionOf(utf8Offset: utf8Offset),
-      let endPosition = snapshot.positionOf(utf8Offset: utf8Offset + length),
       length > 0 || !replacement.isEmpty
     {
       // Snippets are only suppored in code completion.
@@ -136,6 +129,8 @@ extension TextEdit {
         return nil
       }
 
+      let position = snapshot.positionOf(utf8Offset: utf8Offset)
+      let endPosition = snapshot.positionOf(utf8Offset: utf8Offset + length)
       self.init(range: position..<endPosition, newText: replacementWithoutPlaceholders)
     } else {
       return nil
@@ -176,24 +171,26 @@ extension Diagnostic {
       let utf8Column: Int = diag[keys.column],
       line > 0, utf8Column > 0
     {
-      range = snapshot.positionOf(zeroBasedLine: line - 1, utf8Column: utf8Column - 1).map(Range.init)
+      range = Range(snapshot.positionOf(zeroBasedLine: line - 1, utf8Column: utf8Column - 1))
     } else if let utf8Offset: Int = diag[keys.offset] {
-      range = snapshot.positionOf(utf8Offset: utf8Offset).map(Range.init)
+      range = Range(snapshot.positionOf(utf8Offset: utf8Offset))
     }
 
     // If the diagnostic has a range associated with it that starts at the same location as the diagnostics position, use it to retrieve a proper range for the diagnostic, instead of just reporting a zero-length range.
     (diag[keys.ranges] as SKDResponseArray?)?.forEach { index, skRange in
-      if let utf8Offset: Int = skRange[keys.offset],
-        let start = snapshot.positionOf(utf8Offset: utf8Offset),
-        start == range?.lowerBound,
-        let length: Int = skRange[keys.length],
-        let end = snapshot.positionOf(utf8Offset: utf8Offset + length)
-      {
-        range = start..<end
-        return false
-      } else {
+      guard let utf8Offset: Int = skRange[keys.offset],
+        let length: Int = skRange[keys.length]
+      else {
+        return true  // continue
+      }
+      let start = snapshot.positionOf(utf8Offset: utf8Offset)
+      let end = snapshot.positionOf(utf8Offset: utf8Offset + length)
+      guard start == range?.lowerBound else {
         return true
       }
+
+      range = start..<end
+      return false  // terminate forEach
     }
 
     guard let range = range else {
@@ -274,22 +271,17 @@ extension Diagnostic {
     )
   }
 
-  init?(
+  init(
     _ diag: SwiftDiagnostics.Diagnostic,
     in snapshot: DocumentSnapshot
   ) {
-    guard let position = snapshot.position(of: diag.position) else {
-      return nil
-    }
     // Start with a zero-length range based on the position.
     // If the diagnostic has highlights associated with it that start at the
     // position, use that as the diagnostic's range.
-    var range = Range(position)
+    var range = Range(snapshot.position(of: diag.position))
     for highlight in diag.highlights {
       let swiftSyntaxRange = highlight.positionAfterSkippingLeadingTrivia..<highlight.endPositionBeforeTrailingTrivia
-      guard let highlightRange = snapshot.range(of: swiftSyntaxRange) else {
-        break
-      }
+      let highlightRange = snapshot.range(of: swiftSyntaxRange)
       if range.upperBound == highlightRange.lowerBound {
         range = range.lowerBound..<highlightRange.upperBound
       } else {
@@ -350,19 +342,10 @@ extension DiagnosticRelatedInformation {
     )
   }
 
-  init?(_ note: Note, in snapshot: DocumentSnapshot) {
+  init(_ note: Note, in snapshot: DocumentSnapshot) {
     let nodeRange = note.node.positionAfterSkippingLeadingTrivia..<note.node.endPositionBeforeTrailingTrivia
-    guard let range = snapshot.range(of: nodeRange) else {
-      logger.error(
-        """
-        Cannot construct DiagnosticRelatedInformation because the range \(nodeRange, privacy: .public) \
-        is out of range of the source file \(snapshot.uri.forLogging).
-        """
-      )
-      return nil
-    }
     self.init(
-      location: Location(uri: snapshot.uri, range: range),
+      location: Location(uri: snapshot.uri, range: snapshot.range(of: nodeRange)),
       message: note.message
     )
   }
diff --git a/Sources/SourceKitLSP/Swift/DocumentFormatting.swift b/Sources/SourceKitLSP/Swift/DocumentFormatting.swift
index 0e280ec4d..ff3051081 100644
--- a/Sources/SourceKitLSP/Swift/DocumentFormatting.swift
+++ b/Sources/SourceKitLSP/Swift/DocumentFormatting.swift
@@ -116,12 +116,8 @@ private func edits(from original: DocumentSnapshot, to edited: String) -> [TextE
   // Map the offset-based edits to line-column based edits to be consumed by LSP
 
   return concurrentEdits.edits.compactMap { (edit) -> TextEdit? in
-    guard let (startLine, startColumn) = original.lineTable.lineAndUTF16ColumnOf(utf8Offset: edit.offset) else {
-      return nil
-    }
-    guard let (endLine, endColumn) = original.lineTable.lineAndUTF16ColumnOf(utf8Offset: edit.endOffset) else {
-      return nil
-    }
+    let (startLine, startColumn) = original.lineTable.lineAndUTF16ColumnOf(utf8Offset: edit.offset)
+    let (endLine, endColumn) = original.lineTable.lineAndUTF16ColumnOf(utf8Offset: edit.endOffset)
     guard let newText = String(bytes: edit.replacement, encoding: .utf8) else {
       logger.fault("Failed to get String from UTF-8 bytes \(edit.replacement)")
       return nil
diff --git a/Sources/SourceKitLSP/Swift/DocumentSymbols.swift b/Sources/SourceKitLSP/Swift/DocumentSymbols.swift
index 24454b797..0fe06cfc6 100644
--- a/Sources/SourceKitLSP/Swift/DocumentSymbols.swift
+++ b/Sources/SourceKitLSP/Swift/DocumentSymbols.swift
@@ -74,13 +74,8 @@ fileprivate final class DocumentSymbolsFinder: SyntaxAnyVisitor {
     if !self.range.overlaps(range) {
       return .skipChildren
     }
-    guard let rangeLowerBound = snapshot.position(of: range.lowerBound),
-      let rangeUpperBound = snapshot.position(of: range.upperBound),
-      let selectionLowerBound = snapshot.position(of: selection.lowerBound),
-      let selectionUpperBound = snapshot.position(of: selection.upperBound)
-    else {
-      return .skipChildren
-    }
+    let positionRange = snapshot.range(of: range)
+    let selectionPositionRange = snapshot.range(of: selection)
 
     // Record MARK comments on the node's leading and trailing trivia in `result` not as a child of `node`.
     visit(node.leadingTrivia, position: node.position)
@@ -94,8 +89,8 @@ fileprivate final class DocumentSymbolsFinder: SyntaxAnyVisitor {
       DocumentSymbol(
         name: name,
         kind: symbolKind,
-        range: rangeLowerBound..<rangeUpperBound,
-        selectionRange: selectionLowerBound..<selectionUpperBound,
+        range: positionRange,
+        selectionRange: selectionPositionRange,
         children: children
       )
     )
@@ -146,17 +141,13 @@ fileprivate final class DocumentSymbolsFinder: SyntaxAnyVisitor {
         let trimmedComment = commentText.trimmingCharacters(in: CharacterSet(["/", "*"]).union(.whitespaces))
         if trimmedComment.starts(with: markPrefix) {
           let markText = trimmedComment.dropFirst(markPrefix.count)
-          guard let rangeLowerBound = snapshot.position(of: position),
-            let rangeUpperBound = snapshot.position(of: position.advanced(by: piece.sourceLength.utf8Length))
-          else {
-            break
-          }
+          let range = snapshot.range(of: position..<position.advanced(by: piece.sourceLength.utf8Length))
           result.append(
             DocumentSymbol(
               name: String(markText),
               kind: .namespace,
-              range: rangeLowerBound..<rangeUpperBound,
-              selectionRange: rangeLowerBound..<rangeUpperBound,
+              range: range,
+              selectionRange: range,
               children: nil
             )
           )
diff --git a/Sources/SourceKitLSP/Swift/FoldingRange.swift b/Sources/SourceKitLSP/Swift/FoldingRange.swift
index db6d3ed7e..7ca633d32 100644
--- a/Sources/SourceKitLSP/Swift/FoldingRange.swift
+++ b/Sources/SourceKitLSP/Swift/FoldingRange.swift
@@ -195,11 +195,8 @@ fileprivate final class FoldingRangeFinder: SyntaxAnyVisitor {
       return .visitChildren
     }
 
-    guard let start: Position = snapshot.positionOf(utf8Offset: start.utf8Offset),
-      let end: Position = snapshot.positionOf(utf8Offset: end.utf8Offset)
-    else {
-      return .visitChildren
-    }
+    let start = snapshot.positionOf(utf8Offset: start.utf8Offset)
+    let end = snapshot.positionOf(utf8Offset: end.utf8Offset)
     let range: FoldingRange
     if lineFoldingOnly {
       // Since the client cannot fold less than a single line, if the
diff --git a/Sources/SourceKitLSP/Swift/OpenInterface.swift b/Sources/SourceKitLSP/Swift/OpenInterface.swift
index 1fbab5815..07a766d93 100644
--- a/Sources/SourceKitLSP/Swift/OpenInterface.swift
+++ b/Sources/SourceKitLSP/Swift/OpenInterface.swift
@@ -101,10 +101,8 @@ extension SwiftLanguageService {
       ])
 
       let dict = try await self.sourcekitd.send(skreq, fileContents: snapshot.text)
-      if let offset: Int = dict[keys.offset],
-        let position = snapshot.positionOf(utf8Offset: offset)
-      {
-        return InterfaceDetails(uri: uri, position: position)
+      if let offset: Int = dict[keys.offset] {
+        return InterfaceDetails(uri: uri, position: snapshot.positionOf(utf8Offset: offset))
       } else {
         return InterfaceDetails(uri: uri, position: nil)
       }
diff --git a/Sources/SourceKitLSP/Swift/RelatedIdentifiers.swift b/Sources/SourceKitLSP/Swift/RelatedIdentifiers.swift
index 32c4e9e47..33aa32f89 100644
--- a/Sources/SourceKitLSP/Swift/RelatedIdentifiers.swift
+++ b/Sources/SourceKitLSP/Swift/RelatedIdentifiers.swift
@@ -65,14 +65,10 @@ extension SwiftLanguageService {
     in snapshot: DocumentSnapshot,
     includeNonEditableBaseNames: Bool
   ) async throws -> RelatedIdentifiersResponse {
-    guard let offset = snapshot.utf8Offset(of: position) else {
-      throw ResponseError.unknown("invalid position \(position)")
-    }
-
     let skreq = sourcekitd.dictionary([
       keys.request: requests.relatedIdents,
       keys.cancelOnSubsequentRequest: 0,
-      keys.offset: offset,
+      keys.offset: snapshot.utf8Offset(of: position),
       keys.sourceFile: snapshot.uri.pseudoPath,
       keys.includeNonEditableBaseNames: includeNonEditableBaseNames ? 1 : 0,
       keys.compilerArgs: await self.buildSettings(for: snapshot.uri)?.compilerArgs as [SKDRequestValue]?,
@@ -90,17 +86,14 @@ extension SwiftLanguageService {
     var relatedIdentifiers: [RelatedIdentifier] = []
 
     results.forEach { _, value in
-      if let offset: Int = value[keys.offset],
-        let start: Position = snapshot.positionOf(utf8Offset: offset),
-        let length: Int = value[keys.length],
-        let end: Position = snapshot.positionOf(utf8Offset: offset + length)
-      {
-        let usage = RenameLocation.Usage(value[keys.nameType], values) ?? .unknown
-        relatedIdentifiers.append(
-          RelatedIdentifier(range: start..<end, usage: usage)
-        )
+      guard let offset: Int = value[keys.offset], let length: Int = value[keys.length] else {
+        return true  // continue
       }
-      return true
+      let start = snapshot.positionOf(utf8Offset: offset)
+      let end = snapshot.positionOf(utf8Offset: offset + length)
+      let usage = RenameLocation.Usage(value[keys.nameType], values) ?? .unknown
+      relatedIdentifiers.append(RelatedIdentifier(range: start..<end, usage: usage))
+      return true  // continue
     }
     return RelatedIdentifiersResponse(relatedIdentifiers: relatedIdentifiers, name: name)
   }
diff --git a/Sources/SourceKitLSP/Swift/SemanticRefactoring.swift b/Sources/SourceKitLSP/Swift/SemanticRefactoring.swift
index a6f94bbcf..95679666b 100644
--- a/Sources/SourceKitLSP/Swift/SemanticRefactoring.swift
+++ b/Sources/SourceKitLSP/Swift/SemanticRefactoring.swift
@@ -48,26 +48,26 @@ struct SemanticRefactoring {
       }
       edits.forEach { _, value in
         // The LSP is zero based, but semantic_refactoring is one based.
-        if let startLine: Int = value[keys.line],
+        guard let startLine: Int = value[keys.line],
           let startColumn: Int = value[keys.column],
-          let startPosition = snapshot.positionOf(
-            zeroBasedLine: startLine - 1,
-            utf8Column: startColumn - 1
-          ),
           let endLine: Int = value[keys.endLine],
           let endColumn: Int = value[keys.endColumn],
-          let endPosition = snapshot.positionOf(
-            zeroBasedLine: endLine - 1,
-            utf8Column: endColumn - 1
-          ),
           let text: String = value[keys.text]
-        {
-          // Snippets are only supported in code completion.
-          // Remove SourceKit placeholders in refactoring actions because they can't be represented in the editor properly.
-          let textWithSnippets = rewriteSourceKitPlaceholders(in: text, clientSupportsSnippets: false)
-          let edit = TextEdit(range: startPosition..<endPosition, newText: textWithSnippets)
-          textEdits.append(edit)
+        else {
+          return true  // continue
         }
+        let startPosition = snapshot.positionOf(
+          zeroBasedLine: startLine - 1,
+          utf8Column: startColumn - 1
+        )
+        let endPosition = snapshot.positionOf(
+          zeroBasedLine: endLine - 1,
+          utf8Column: endColumn - 1
+        )
+        // Snippets are only supported in code completion.
+        // Remove SourceKit placeholders in refactoring actions because they can't be represented in the editor properly.
+        let textWithSnippets = rewriteSourceKitPlaceholders(in: text, clientSupportsSnippets: false)
+        textEdits.append(TextEdit(range: startPosition..<endPosition, newText: textWithSnippets))
         return true
       }
       return true
@@ -84,12 +84,6 @@ struct SemanticRefactoring {
 
 /// An error from a semantic refactoring request.
 enum SemanticRefactoringError: Error {
-  /// The given position range is invalid.
-  case invalidRange(Range<Position>)
-
-  /// The given position failed to convert to UTF-8.
-  case failedToRetrieveOffset(Range<Position>)
-
   /// The underlying sourcekitd request failed with the given error.
   case responseError(ResponseError)
 
@@ -100,10 +94,6 @@ enum SemanticRefactoringError: Error {
 extension SemanticRefactoringError: CustomStringConvertible {
   var description: String {
     switch self {
-    case .invalidRange(let range):
-      return "failed to refactor due to invalid range: \(range)"
-    case .failedToRetrieveOffset(let range):
-      return "Failed to convert range to UTF-8 offset: \(range)"
     case .responseError(let error):
       return "\(error)"
     case .noEditsNeeded(let url):
@@ -128,14 +118,9 @@ extension SwiftLanguageService {
 
     let uri = refactorCommand.textDocument.uri
     let snapshot = try self.documentManager.latestSnapshot(uri)
-    guard let offsetRange = snapshot.utf8OffsetRange(of: refactorCommand.positionRange) else {
-      throw SemanticRefactoringError.failedToRetrieveOffset(refactorCommand.positionRange)
-    }
     let line = refactorCommand.positionRange.lowerBound.line
     let utf16Column = refactorCommand.positionRange.lowerBound.utf16index
-    guard let utf8Column = snapshot.lineTable.utf8ColumnAt(line: line, utf16Column: utf16Column) else {
-      throw SemanticRefactoringError.invalidRange(refactorCommand.positionRange)
-    }
+    let utf8Column = snapshot.lineTable.utf8ColumnAt(line: line, utf16Column: utf16Column)
 
     let skreq = sourcekitd.dictionary([
       keys.request: self.requests.semanticRefactoring,
@@ -146,7 +131,7 @@ extension SwiftLanguageService {
       // LSP is zero based, but this request is 1 based.
       keys.line: line + 1,
       keys.column: utf8Column + 1,
-      keys.length: offsetRange.count,
+      keys.length: snapshot.utf8OffsetRange(of: refactorCommand.positionRange).count,
       keys.actionUID: self.sourcekitd.api.uid_get_from_cstr(refactorCommand.actionString)!,
       keys.compilerArgs: await self.buildSettings(for: snapshot.uri)?.compilerArgs as [SKDRequestValue]?,
     ])
diff --git a/Sources/SourceKitLSP/Swift/SemanticTokens.swift b/Sources/SourceKitLSP/Swift/SemanticTokens.swift
index ccf8acc73..47782f9b6 100644
--- a/Sources/SourceKitLSP/Swift/SemanticTokens.swift
+++ b/Sources/SourceKitLSP/Swift/SemanticTokens.swift
@@ -107,14 +107,7 @@ extension SyntaxClassifiedRange {
       return SyntaxHighlightingTokens(tokens: [])
     }
 
-    guard
-      let start: Position = snapshot.positionOf(utf8Offset: self.offset),
-      let end: Position = snapshot.positionOf(utf8Offset: self.endOffset)
-    else {
-      return SyntaxHighlightingTokens(tokens: [])
-    }
-
-    let multiLineRange = start..<end
+    let multiLineRange = snapshot.positionOf(utf8Offset: self.offset)..<snapshot.positionOf(utf8Offset: self.endOffset)
     let ranges = multiLineRange.splitToSingleLineRanges(in: snapshot)
 
     let tokens = ranges.map {
diff --git a/Sources/SourceKitLSP/Swift/SwiftLanguageService.swift b/Sources/SourceKitLSP/Swift/SwiftLanguageService.swift
index 2159a6d09..878dc0000 100644
--- a/Sources/SourceKitLSP/Swift/SwiftLanguageService.swift
+++ b/Sources/SourceKitLSP/Swift/SwiftLanguageService.swift
@@ -654,15 +654,9 @@ extension SwiftLanguageService {
           return .skipChildren
         }
 
-        guard let startPosition = snapshot.position(of: node.position),
-          let endPosition = snapshot.position(of: node.endPosition)
-        else {
-          return .skipChildren
-        }
-
         result.append(
           ColorInformation(
-            range: startPosition..<endPosition,
+            range: snapshot.range(of: node.position..<node.endPosition),
             color: Color(red: red, green: green, blue: blue, alpha: alpha)
           )
         )
@@ -940,28 +934,37 @@ extension DocumentSnapshot {
 
   /// Converts the given UTF-8 offset to `String.Index`.
   ///
-  /// If the offset is after the end of the snapshot, returns `nil` and logs a fault containing the file and line of
-  /// the caller (from `callerFile` and `callerLine`).
-  func indexOf(utf8Offset: Int, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> String.Index? {
+  /// If the offset is out-of-bounds of the snapshot, returns the closest valid index and logs a fault containing the
+  /// file and line of the caller (from `callerFile` and `callerLine`).
+  func indexOf(utf8Offset: Int, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> String.Index {
+    guard utf8Offset >= 0 else {
+      logger.fault(
+        """
+        UTF-8 offset \(utf8Offset) is negative while converting it to String.Index \
+        (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
+        """
+      )
+      return text.startIndex
+    }
     guard let index = text.utf8.index(text.startIndex, offsetBy: utf8Offset, limitedBy: text.endIndex) else {
       logger.fault(
         """
-        Unable to get String index for UTF-8 offset \(utf8Offset) because offset is out of range \
+        UTF-8 offset \(utf8Offset) is past end of file while converting it to String.Index \
         (\(callerFile, privacy: .public):\(callerLine, privacy: .public))
         """
       )
-      return nil
+      return text.endIndex
     }
     return index
   }
 
-  // MARK: Position <-> Raw UTF-8
+  // MARK: Position <-> Raw UTF-8 offset
 
   /// Converts the given UTF-16-based line:column position to the UTF-8 offset of that position within the source file.
   ///
-  /// If `position` does not refer to a valid position with in the snapshot, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
-  func utf8Offset(of position: Position, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> Int? {
+  /// If `position` does not refer to a valid position with in the snapshot, returns the offset of the closest valid
+  /// position and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  func utf8Offset(of position: Position, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> Int {
     return lineTable.utf8OffsetOf(
       line: position.line,
       utf16Column: position.utf16index,
@@ -970,75 +973,78 @@ extension DocumentSnapshot {
     )
   }
 
-  // MARK: Position <-> String.Index
-
-  /// Converts the given UTF-16-based `line:column`` position to a `String.Index`.
+  /// Converts the given UTF-8 offset to a UTF-16-based line:column position.
   ///
-  /// If `position` does not refer to a valid position with in the snapshot, returns `nil` and logs a fault
-  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
-  func index(of position: Position, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> String.Index? {
-    return lineTable.stringIndexOf(
-      line: position.line,
-      utf16Column: position.utf16index,
+  /// If the offset is after the end of the snapshot, returns `nil` and logs a fault containing the file and line of
+  /// the caller (from `callerFile` and `callerLine`).
+  func positionOf(utf8Offset: Int, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> Position {
+    let (line, utf16Column) = lineTable.lineAndUTF16ColumnOf(
+      utf8Offset: utf8Offset,
       callerFile: callerFile,
       callerLine: callerLine
     )
+    return Position(line: line, utf16index: utf16Column)
   }
 
   /// Converts the given UTF-16 based line:column range to a UTF-8 based offset range.
   ///
-  /// If either the lower or upper bound of `range` do not refer to valid positions with in the snapshot, returns
-  /// `nil` and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the bounds of the range do not refer to a valid positions with in the snapshot, this function adjusts them to
+  /// the closest valid positions and logs a fault containing the file and line of the caller (from `callerFile` and
+  /// `callerLine`).
   func utf8OffsetRange(
     of range: Range<Position>,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Range<Int>? {
-    guard let startOffset = utf8Offset(of: range.lowerBound, callerFile: callerFile, callerLine: callerLine),
-      let endOffset = utf8Offset(of: range.upperBound, callerFile: callerFile, callerLine: callerLine)
-    else {
-      return nil
-    }
+  ) -> Range<Int> {
+    let startOffset = utf8Offset(of: range.lowerBound, callerFile: callerFile, callerLine: callerLine)
+    let endOffset = utf8Offset(of: range.upperBound, callerFile: callerFile, callerLine: callerLine)
     return startOffset..<endOffset
   }
 
-  /// Converts the given UTF-8 offset to a UTF-16-based line:column position.
+  // MARK: Position <-> String.Index
+
+  /// Converts the given UTF-16-based `line:column` position to a `String.Index`.
   ///
-  /// If the offset is after the end of the snapshot, returns `nil` and logs a fault containing the file and line of
-  /// the caller (from `callerFile` and `callerLine`).
-  func positionOf(utf8Offset: Int, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> Position? {
-    guard
-      let (line, utf16Column) = lineTable.lineAndUTF16ColumnOf(
-        utf8Offset: utf8Offset,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
-    return Position(line: line, utf16index: utf16Column)
+  /// If `position` does not refer to a valid position with in the snapshot, returns the index of the closest valid
+  /// position and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  func index(of position: Position, callerFile: StaticString = #fileID, callerLine: UInt = #line) -> String.Index {
+    return lineTable.stringIndexOf(
+      line: position.line,
+      utf16Column: position.utf16index,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
+  }
+
+  /// Converts the given UTF-16-based `line:column` range to a `String.Index` range.
+  ///
+  /// If the bounds of the range do not refer to a valid positions with in the snapshot, this function adjusts them to
+  /// the closest valid positions and logs a fault containing the file and line of the caller (from `callerFile` and
+  /// `callerLine`).
+  func indexRange(
+    of range: Range<Position>,
+    callerFile: StaticString = #fileID,
+    callerLine: UInt = #line
+  ) -> Range<String.Index> {
+    return self.index(of: range.lowerBound)..<self.index(of: range.upperBound)
   }
 
   /// Converts the given UTF-8 based line:column position to a UTF-16 based line-column position.
   ///
-  /// If the UTF-8 based line:column pair does not refer to a valid position within the snapshot, returns `nil` and logs
-  /// a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the UTF-8 based line:column pair does not refer to a valid position within the snapshot, returns the closest
+  /// valid position and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   func positionOf(
     zeroBasedLine: Int,
     utf8Column: Int,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Position? {
-    guard
-      let utf16Column = lineTable.utf16ColumnAt(
-        line: zeroBasedLine,
-        utf8Column: utf8Column,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
+  ) -> Position {
+    let utf16Column = lineTable.utf16ColumnAt(
+      line: zeroBasedLine,
+      utf8Column: utf8Column,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
     return Position(line: zeroBasedLine, utf16index: utf16Column)
   }
 
@@ -1046,61 +1052,56 @@ extension DocumentSnapshot {
 
   /// Converts the given UTF-8-offset-based `AbsolutePosition` to a UTF-16-based line:column.
   ///
-  /// If the `AbsolutePosition` out of bounds of the source file, returns `nil` and logs a fault containing the file and
-  /// line of the caller (from `callerFile` and `callerLine`).
+  /// If the `AbsolutePosition` out of bounds of the source file, returns the closest valid position and logs a fault
+  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
   func position(
     of position: AbsolutePosition,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Position? {
+  ) -> Position {
     return positionOf(utf8Offset: position.utf8Offset, callerFile: callerFile, callerLine: callerLine)
   }
 
   /// Converts the given UTF-16-based line:column `Position` to a UTF-8-offset-based `AbsolutePosition`.
   ///
-  /// If the UTF-16 based line:column pair does not refer to a valid position within the snapshot, returns `nil` and
-  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the UTF-16 based line:column pair does not refer to a valid position within the snapshot, returns the closest
+  /// valid position and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   func absolutePosition(
     of position: Position,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> AbsolutePosition? {
-    guard let offset = utf8Offset(of: position, callerFile: callerFile, callerLine: callerLine) else {
-      return nil
-    }
+  ) -> AbsolutePosition {
+    let offset = utf8Offset(of: position, callerFile: callerFile, callerLine: callerLine)
     return AbsolutePosition(utf8Offset: offset)
   }
 
   /// Converts the lower and upper bound of the given UTF-8-offset-based `AbsolutePosition` range to a UTF-16-based
   /// line:column range for use in LSP.
   ///
-  /// If either the lower or the upper bound of the range is out of bounds of the source file, returns `nil` and logs
-  /// a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the bounds of the range do not refer to a valid positions with in the snapshot, this function adjusts them to
+  /// the closest valid positions and logs a fault containing the file and line of the caller (from `callerFile` and
+  /// `callerLine`).
   func range(
     of range: Range<AbsolutePosition>,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Range<Position>? {
-    guard let lowerBound = self.position(of: range.lowerBound, callerFile: callerFile, callerLine: callerLine),
-      let upperBound = self.position(of: range.upperBound, callerFile: callerFile, callerLine: callerLine)
-    else {
-      return nil
-    }
+  ) -> Range<Position> {
+    let lowerBound = self.position(of: range.lowerBound, callerFile: callerFile, callerLine: callerLine)
+    let upperBound = self.position(of: range.upperBound, callerFile: callerFile, callerLine: callerLine)
     return lowerBound..<upperBound
   }
 
   /// Converts the given UTF-16-based line:column range to a UTF-8-offset-based `ByteSourceRange`.
   ///
-  /// If either the lower or upper bound of the range does not refer to a valid position within the snapshot, returns
-  /// `nil` and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the bounds of the range do not refer to a valid positions with in the snapshot, this function adjusts them to
+  /// the closest valid positions and logs a fault containing the file and line of the caller (from `callerFile` and
+  /// `callerLine`).
   func byteSourceRange(
     of range: Range<Position>,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> ByteSourceRange? {
-    guard let utf8OffsetRange = utf8OffsetRange(of: range, callerFile: callerFile, callerLine: callerLine) else {
-      return nil
-    }
+  ) -> ByteSourceRange {
+    let utf8OffsetRange = utf8OffsetRange(of: range, callerFile: callerFile, callerLine: callerLine)
     return ByteSourceRange(offset: utf8OffsetRange.startIndex, length: utf8OffsetRange.count)
   }
 
@@ -1108,13 +1109,13 @@ extension DocumentSnapshot {
 
   /// Converts the given UTF-8-based line:column `RenamedLocation` to a UTF-16-based line:column `Position`.
   ///
-  /// If the UTF-8 based line:column pair does not refer to a valid position within the snapshot, returns `nil` and
-  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the UTF-8 based line:column pair does not refer to a valid position within the snapshot, returns the closest
+  /// valid position and logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
   func position(
     of renameLocation: RenameLocation,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Position? {
+  ) -> Position {
     return positionOf(
       zeroBasedLine: renameLocation.line - 1,
       utf8Column: renameLocation.utf8Column - 1,
@@ -1127,13 +1128,13 @@ extension DocumentSnapshot {
 
   /// Converts the given UTF-8-offset-based `SymbolLocation` to a UTF-16-based line:column `Position`.
   ///
-  /// If the UTF-8 offset is out-of-bounds of the snapshot, returns `nil` and  logs a fault containing the file and line
-  /// of the caller (from `callerFile` and `callerLine`).
+  /// If the UTF-8 offset is out-of-bounds of the snapshot, returns the closest valid position and logs a fault
+  /// containing the file and line of the caller (from `callerFile` and `callerLine`).
   func position(
     of symbolLocation: SymbolLocation,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> Position? {
+  ) -> Position {
     return positionOf(
       zeroBasedLine: symbolLocation.line - 1,
       utf8Column: symbolLocation.utf8Column - 1,
@@ -1146,23 +1147,20 @@ extension DocumentSnapshot {
 
   /// Converts the given UTF-8-based line:column `RenamedLocation` to a UTF-8-offset-based `AbsolutePosition`.
   ///
-  /// If the UTF-8 based line:column pair does not refer to a valid position within the snapshot, returns `nil` and
-  /// logs a fault containing the file and line of the caller (from `callerFile` and `callerLine`).
+  /// If the UTF-8 based line:column pair does not refer to a valid position within the snapshot, returns the offset of
+  /// the closest valid position and logs a fault containing the file and line of the caller (from `callerFile` and
+  /// `callerLine`).
   func absolutePosition(
     of renameLocation: RenameLocation,
     callerFile: StaticString = #fileID,
     callerLine: UInt = #line
-  ) -> AbsolutePosition? {
-    guard
-      let utf8Offset = lineTable.utf8OffsetOf(
-        line: renameLocation.line - 1,
-        utf8Column: renameLocation.utf8Column - 1,
-        callerFile: callerFile,
-        callerLine: callerLine
-      )
-    else {
-      return nil
-    }
+  ) -> AbsolutePosition {
+    let utf8Offset = lineTable.utf8OffsetOf(
+      line: renameLocation.line - 1,
+      utf8Column: renameLocation.utf8Column - 1,
+      callerFile: callerFile,
+      callerLine: callerLine
+    )
     return AbsolutePosition(utf8Offset: utf8Offset)
   }
 }
diff --git a/Sources/SourceKitLSP/Swift/SyntaxHighlightingTokenParser.swift b/Sources/SourceKitLSP/Swift/SyntaxHighlightingTokenParser.swift
index 1b05cb57e..6733a7777 100644
--- a/Sources/SourceKitLSP/Swift/SyntaxHighlightingTokenParser.swift
+++ b/Sources/SourceKitLSP/Swift/SyntaxHighlightingTokenParser.swift
@@ -31,7 +31,6 @@ struct SyntaxHighlightingTokenParser {
 
     if let offset: Int = response[keys.offset],
       var length: Int = response[keys.length],
-      let start: Position = snapshot.positionOf(utf8Offset: offset),
       let skKind: sourcekitd_api_uid_t = response[keys.kind],
       case (let kind, var modifiers)? = parseKindAndModifiers(skKind)
     {
@@ -39,7 +38,7 @@ struct SyntaxHighlightingTokenParser {
       // If the name is escaped in backticks, we need to add two characters to the
       // length for the backticks.
       if modifiers.contains(.declaration),
-        let index = snapshot.indexOf(utf8Offset: offset), snapshot.text[index] == "`"
+        snapshot.text[snapshot.indexOf(utf8Offset: offset)] == "`"
       {
         length += 2
       }
@@ -48,17 +47,15 @@ struct SyntaxHighlightingTokenParser {
         modifiers.insert(.defaultLibrary)
       }
 
-      if let end: Position = snapshot.positionOf(utf8Offset: offset + length) {
-        let multiLineRange = start..<end
-        let ranges = multiLineRange.splitToSingleLineRanges(in: snapshot)
-
-        tokens.tokens += ranges.map {
-          SyntaxHighlightingToken(
-            range: $0,
-            kind: kind,
-            modifiers: modifiers
-          )
-        }
+      let multiLineRange = snapshot.positionOf(utf8Offset: offset)..<snapshot.positionOf(utf8Offset: offset + length)
+      let ranges = multiLineRange.splitToSingleLineRanges(in: snapshot)
+
+      tokens.tokens += ranges.map {
+        SyntaxHighlightingToken(
+          range: $0,
+          kind: kind,
+          modifiers: modifiers
+        )
       }
     }
 
@@ -217,14 +214,7 @@ extension Range<Position> {
       return [self]
     }
 
-    guard let startIndex = snapshot.index(of: lowerBound),
-      let endIndex = snapshot.index(of: upperBound)
-    else {
-      logger.fault("Range \(self) reaches outside of the document")
-      return [self]
-    }
-
-    let text = snapshot.text[startIndex..<endIndex]
+    let text = snapshot.text[snapshot.indexRange(of: self)]
     let lines = text.split(separator: "\n", omittingEmptySubsequences: false)
 
     return
diff --git a/Sources/SourceKitLSP/Swift/VariableTypeInfo.swift b/Sources/SourceKitLSP/Swift/VariableTypeInfo.swift
index edb48c987..fd45dd0be 100644
--- a/Sources/SourceKitLSP/Swift/VariableTypeInfo.swift
+++ b/Sources/SourceKitLSP/Swift/VariableTypeInfo.swift
@@ -60,8 +60,6 @@ struct VariableTypeInfo {
 
     guard let offset: Int = dict[keys.variableOffset],
       let length: Int = dict[keys.variableLength],
-      let startIndex = snapshot.positionOf(utf8Offset: offset),
-      let endIndex = snapshot.positionOf(utf8Offset: offset + length),
       let printedType: String = dict[keys.variableType],
       let hasExplicitType: Bool = dict[keys.variableTypeExplicit]
     else {
@@ -69,7 +67,7 @@ struct VariableTypeInfo {
     }
     let tokenAtOffset = syntaxTree.token(at: AbsolutePosition(utf8Offset: offset))
 
-    self.range = startIndex..<endIndex
+    self.range = snapshot.positionOf(utf8Offset: offset)..<snapshot.positionOf(utf8Offset: offset + length)
     self.printedType = printedType
     self.hasExplicitType = hasExplicitType
     self.canBeFollowedByTypeAnnotation = tokenAtOffset?.canBeFollowedByTypeAnnotation ?? true
@@ -93,10 +91,9 @@ extension SwiftLanguageService {
       keys.compilerArgs: await self.buildSettings(for: uri)?.compilerArgs as [SKDRequestValue]?,
     ])
 
-    if let range = range,
-      let start = snapshot.utf8Offset(of: range.lowerBound),
+    if let range = range {
+      let start = snapshot.utf8Offset(of: range.lowerBound)
       let end = snapshot.utf8Offset(of: range.upperBound)
-    {
       skreq.set(keys.offset, to: start)
       skreq.set(keys.length, to: end - start)
     }
diff --git a/Sources/SourceKitLSP/TestDiscovery.swift b/Sources/SourceKitLSP/TestDiscovery.swift
index 77c35a08c..4b59eb037 100644
--- a/Sources/SourceKitLSP/TestDiscovery.swift
+++ b/Sources/SourceKitLSP/TestDiscovery.swift
@@ -105,10 +105,8 @@ extension SourceKitLSPServer {
       let symbolPosition: Position
       if let snapshot = try? documentManager.latestSnapshot(
         DocumentURI(URL(fileURLWithPath: testSymbolOccurrence.location.path))
-      ),
-        let position = snapshot.position(of: testSymbolOccurrence.location)
-      {
-        symbolPosition = position
+      ) {
+        symbolPosition = snapshot.position(of: testSymbolOccurrence.location)
       } else {
         // Technically, we always need to convert UTF-8 columns to UTF-16 columns, which requires reading the file.
         // In practice, they are almost always the same.
@@ -256,13 +254,10 @@ private final class SyntacticSwiftXCTestScanner: SyntaxVisitor {
         // declarations are probably less common than helper functions that start with `test` and have a return type.
         return nil
       }
-      guard
-        let range = snapshot.range(
-          of: function.positionAfterSkippingLeadingTrivia..<function.endPositionBeforeTrailingTrivia
-        )
-      else {
-        return nil
-      }
+      let range = snapshot.range(
+        of: function.positionAfterSkippingLeadingTrivia..<function.endPositionBeforeTrailingTrivia
+      )
+
       return TestItem(
         id: "\(containerName)/\(function.name.text)()",
         label: "\(function.name.text)()",
@@ -292,10 +287,7 @@ private final class SyntacticSwiftXCTestScanner: SyntaxVisitor {
       // Don't report a test class if it doesn't contain any test methods.
       return .visitChildren
     }
-    guard let range = snapshot.range(of: node.positionAfterSkippingLeadingTrivia..<node.endPositionBeforeTrailingTrivia)
-    else {
-      return .visitChildren
-    }
+    let range = snapshot.range(of: node.positionAfterSkippingLeadingTrivia..<node.endPositionBeforeTrailingTrivia)
     let testItem = TestItem(
       id: node.name.text,
       label: node.name.text,
diff --git a/Tests/SKSupportTests/SupportTests.swift b/Tests/SKSupportTests/SupportTests.swift
index c8856a52e..397d4a931 100644
--- a/Tests/SKSupportTests/SupportTests.swift
+++ b/Tests/SKSupportTests/SupportTests.swift
@@ -76,24 +76,18 @@ final class SupportTests: XCTestCase {
   func checkLineAndColumns(
     _ table: LineTable,
     _ utf8Offset: Int,
-    _ expected: (line: Int, utf16Column: Int)?,
+    _ expected: (line: Int, utf16Column: Int),
     file: StaticString = #filePath,
     line: UInt = #line
   ) {
-    switch (table.lineAndUTF16ColumnOf(utf8Offset: utf8Offset), expected) {
-    case (nil, nil):
-      break
-    case (let result?, let _expected?):
-      XCTAssertTrue(result == _expected, "\(result) != \(_expected)", file: file, line: line)
-    case (let result, let _expected):
-      XCTFail("\(String(describing: result)) != \(String(describing: _expected))", file: file, line: line)
-    }
+    let actual = table.lineAndUTF16ColumnOf(utf8Offset: utf8Offset)
+    XCTAssert(actual == expected, "\(actual) != \(expected)", file: file, line: line)
   }
 
   func checkUTF8OffsetOf(
     _ table: LineTable,
     _ query: (line: Int, utf16Column: Int),
-    _ expected: Int?,
+    _ expected: Int,
     file: StaticString = #filePath,
     line: UInt = #line
   ) {
@@ -108,7 +102,7 @@ final class SupportTests: XCTestCase {
   func checkUTF16ColumnAt(
     _ table: LineTable,
     _ query: (line: Int, utf8Column: Int),
-    _ expected: Int?,
+    _ expected: Int,
     file: StaticString = #filePath,
     line: UInt = #line
   ) {
@@ -135,25 +129,25 @@ final class SupportTests: XCTestCase {
     checkLineAndColumns(t1, 9, (line: 1, utf16Column: 4))
     checkLineAndColumns(t1, 10, (line: 2, utf16Column: 0))
     checkLineAndColumns(t1, 14, (line: 2, utf16Column: 4))
-    checkLineAndColumns(t1, 15, nil)
+    checkLineAndColumns(t1, 15, (line: 2, utf16Column: 4))
 
     checkUTF8OffsetOf(t1, (line: 0, utf16Column: 0), 0)
     checkUTF8OffsetOf(t1, (line: 0, utf16Column: 2), 2)
     checkUTF8OffsetOf(t1, (line: 0, utf16Column: 4), 4)
     checkUTF8OffsetOf(t1, (line: 0, utf16Column: 5), 5)
-    checkUTF8OffsetOf(t1, (line: 0, utf16Column: 6), nil)
+    checkUTF8OffsetOf(t1, (line: 0, utf16Column: 6), 5)  // Recovers to end of line 0
     checkUTF8OffsetOf(t1, (line: 1, utf16Column: 0), 5)
     checkUTF8OffsetOf(t1, (line: 1, utf16Column: 4), 9)
     checkUTF8OffsetOf(t1, (line: 2, utf16Column: 0), 10)
     checkUTF8OffsetOf(t1, (line: 2, utf16Column: 4), 14)
-    checkUTF8OffsetOf(t1, (line: 2, utf16Column: 5), nil)
-    checkUTF8OffsetOf(t1, (line: 3, utf16Column: 0), nil)
+    checkUTF8OffsetOf(t1, (line: 2, utf16Column: 5), 14)  // Recovers to end of line 2
+    checkUTF8OffsetOf(t1, (line: 3, utf16Column: 0), 14)  // Recovers to end of source file
 
     checkUTF16ColumnAt(t1, (line: 0, utf8Column: 4), 4)
     checkUTF16ColumnAt(t1, (line: 0, utf8Column: 5), 5)
-    checkUTF16ColumnAt(t1, (line: 0, utf8Column: 6), nil)
+    checkUTF16ColumnAt(t1, (line: 0, utf8Column: 6), 5)  // Recovers to end of line 0
     checkUTF16ColumnAt(t1, (line: 2, utf8Column: 0), 0)
-    checkUTF16ColumnAt(t1, (line: 3, utf8Column: 0), nil)
+    checkUTF16ColumnAt(t1, (line: 3, utf8Column: 0), 0)  // Line out of bounds, so keeps column
 
     let t2 = LineTable(
       """
@@ -174,11 +168,11 @@ final class SupportTests: XCTestCase {
     checkUTF8OffsetOf(t2, (line: 0, utf16Column: 6), 16)
     checkUTF8OffsetOf(t2, (line: 1, utf16Column: 1), 19)
     checkUTF8OffsetOf(t2, (line: 1, utf16Column: 6), 32)
-    checkUTF8OffsetOf(t2, (line: 1, utf16Column: 7), nil)
+    checkUTF8OffsetOf(t2, (line: 1, utf16Column: 7), 32)  // Recovers to end of line 1
     checkUTF8OffsetOf(t2, (line: 2, utf16Column: 0), 32)
     checkUTF8OffsetOf(t2, (line: 2, utf16Column: 2), 36)
     checkUTF8OffsetOf(t2, (line: 2, utf16Column: 4), 40)
-    checkUTF8OffsetOf(t2, (line: 2, utf16Column: 5), nil)
+    checkUTF8OffsetOf(t2, (line: 2, utf16Column: 5), 40)  // Recovers to end of line 2
 
     checkUTF16ColumnAt(t2, (line: 0, utf8Column: 3), 1)
     checkUTF16ColumnAt(t2, (line: 0, utf8Column: 15), 5)