diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h
index acc3f3d6bc0fa..5d45e37c25ca9 100644
--- a/include/swift/AST/ASTBridging.h
+++ b/include/swift/AST/ASTBridging.h
@@ -65,7 +65,7 @@ inline const void *_Nullable BridgedIdentifier_raw(BridgedIdentifier ident) {
   return ident.Raw;
 }
 
-struct BridgedIdentifierAndSourceLoc {
+struct BridgedLocatedIdentifier {
   SWIFT_NAME("name")
   BridgedIdentifier Name;
 
diff --git a/lib/AST/ASTBridging.cpp b/lib/AST/ASTBridging.cpp
index 2832e9dd27e82..126d9ad69145e 100644
--- a/lib/AST/ASTBridging.cpp
+++ b/lib/AST/ASTBridging.cpp
@@ -110,16 +110,7 @@ BridgedDeclNameLoc_createParsed(BridgedSourceLoc cBaseNameLoc) {
 
 BridgedIdentifier BridgedASTContext_getIdentifier(BridgedASTContext cContext,
                                                   BridgedStringRef cStr) {
-  StringRef str = cStr.unbridged();
-  if (str.size() == 1 && str.front() == '_')
-    return BridgedIdentifier();
-
-  // If this was a back-ticked identifier, drop the back-ticks.
-  if (str.size() >= 2 && str.front() == '`' && str.back() == '`') {
-    str = str.drop_front().drop_back();
-  }
-
-  return cContext.unbridged().getIdentifier(str);
+  return cContext.unbridged().getIdentifier(cStr.unbridged());
 }
 
 bool BridgedASTContext_langOptsHasFeature(BridgedASTContext cContext,
@@ -681,8 +672,7 @@ BridgedNominalTypeDecl BridgedProtocolDecl_createParsed(
 
   auto primaryAssociatedTypeNames =
       context.AllocateTransform<PrimaryAssociatedTypeName>(
-          cPrimaryAssociatedTypeNames
-              .unbridged<BridgedIdentifierAndSourceLoc>(),
+          cPrimaryAssociatedTypeNames.unbridged<BridgedLocatedIdentifier>(),
           [](auto &e) -> PrimaryAssociatedTypeName {
             return {e.Name.unbridged(), e.NameLoc.unbridged()};
           });
@@ -781,15 +771,13 @@ BridgedPrecedenceGroupDecl BridgedPrecedenceGroupDecl_createParsed(
     BridgedSourceLoc cRightBraceLoc) {
 
   SmallVector<PrecedenceGroupDecl::Relation, 2> higherThanNames;
-  for (auto &pair :
-       cHigherThanNames.unbridged<BridgedIdentifierAndSourceLoc>()) {
+  for (auto &pair : cHigherThanNames.unbridged<BridgedLocatedIdentifier>()) {
     higherThanNames.push_back(
         {pair.NameLoc.unbridged(), pair.Name.unbridged(), nullptr});
   }
 
   SmallVector<PrecedenceGroupDecl::Relation, 2> lowerThanNames;
-  for (auto &pair :
-       cLowerThanNames.unbridged<BridgedIdentifierAndSourceLoc>()) {
+  for (auto &pair : cLowerThanNames.unbridged<BridgedLocatedIdentifier>()) {
     lowerThanNames.push_back(
         {pair.NameLoc.unbridged(), pair.Name.unbridged(), nullptr});
   }
@@ -811,7 +799,7 @@ BridgedImportDecl BridgedImportDecl_createParsed(
     BridgedSourceLoc cImportKindLoc, BridgedArrayRef cImportPathElements) {
   ImportPath::Builder builder;
   for (auto &element :
-       cImportPathElements.unbridged<BridgedIdentifierAndSourceLoc>()) {
+       cImportPathElements.unbridged<BridgedLocatedIdentifier>()) {
     builder.push_back(element.Name.unbridged(), element.NameLoc.unbridged());
   }
 
diff --git a/lib/ASTGen/Sources/ASTGen/ASTGen.swift b/lib/ASTGen/Sources/ASTGen/ASTGen.swift
index 71900c92a3437..90fecf70caf92 100644
--- a/lib/ASTGen/Sources/ASTGen/ASTGen.swift
+++ b/lib/ASTGen/Sources/ASTGen/ASTGen.swift
@@ -14,7 +14,7 @@ import ASTBridging
 import BasicBridging
 import ParseBridging
 // Needed to use BumpPtrAllocator
-@_spi(BumpPtrAllocator) import SwiftSyntax
+@_spi(BumpPtrAllocator) @_spi(RawSyntax) import SwiftSyntax
 
 import struct SwiftDiagnostics.Diagnostic
 
@@ -106,7 +106,7 @@ struct ASTGenVisitor {
     var out = [BridgedDecl]()
 
     for element in node.statements {
-      let loc = element.bridgedSourceLoc(in: self)
+      let loc = self.generateSourceLoc(element)
       let swiftASTNodes = generate(codeBlockItem: element)
       switch swiftASTNodes {
       case .decl(let d):
@@ -138,6 +138,82 @@ struct ASTGenVisitor {
   }
 }
 
+extension ASTGenVisitor {
+  /// Obtains a bridged, `ASTContext`-owned "identifier".
+  ///
+  /// If the token text is `_`, return an empty identifier. If the token is an
+  /// escaped identifier, backticks are stripped.
+  @inline(__always)
+  func generateIdentifier(_ token: TokenSyntax) -> BridgedIdentifier {
+    var text = token.rawText
+    // FIXME: Maybe `TokenSyntax.tokenView.rawKind == .wildcard`, or expose it as `.rawTokenKind`.
+    if text == "_" {
+      return nil
+    }
+    if text.count > 2 && text.hasPrefix("`") && text.hasSuffix("`") {
+      text = .init(rebasing: text.dropFirst().dropLast())
+    }
+    return self.ctx.getIdentifier(text.bridged)
+  }
+
+  /// Obtains a bridged, `ASTContext`-owned "identifier".
+  ///
+  /// If the `token` text is `nil`, return an empty identifier.
+  @inline(__always)
+  func generateIdentifier(_ token: TokenSyntax?) -> BridgedIdentifier {
+    token.map(generateIdentifier(_:)) ?? nil
+  }
+
+  /// Obtains the start location of the node excluding leading trivia in the
+  /// source buffer.
+  @inline(__always)
+  func generateSourceLoc(_ node: some SyntaxProtocol) -> BridgedSourceLoc {
+    BridgedSourceLoc(at: node.positionAfterSkippingLeadingTrivia, in: self.base)
+  }
+
+  /// Obtains the start location of the node excluding leading trivia in the
+  /// source buffer. If the `node` is nil returns an invalid source location.
+  @inline(__always)
+  func generateSourceLoc(_ node: (some SyntaxProtocol)?) -> BridgedSourceLoc {
+    node.map(generateSourceLoc(_:)) ?? nil
+  }
+
+  /// Obtains a pair of bridged identifier and the bridged source location.
+  @inline(__always)
+  func generateIdentifierAndSourceLoc(_ token: TokenSyntax) -> (identifier: BridgedIdentifier, sourceLoc: BridgedSourceLoc) {
+    return (
+      self.generateIdentifier(token),
+      self.generateSourceLoc(token)
+    )
+  }
+
+  /// Obtains a pair of bridged identifier and the bridged source location.
+  /// If `token` is `nil`, returns a pair of an empty identifier and an invalid
+  /// source location.
+  @inline(__always)
+  func generateIdentifierAndSourceLoc(_ token: TokenSyntax?) -> (identifier: BridgedIdentifier, sourceLoc: BridgedSourceLoc) {
+    token.map(generateIdentifierAndSourceLoc(_:)) ?? (nil, nil)
+  }
+
+  /// Obtains a pair of bridged identifier and the bridged source location.
+  @inline(__always)
+  func generateLocatedIdentifier(_ token: TokenSyntax) -> BridgedLocatedIdentifier {
+    BridgedLocatedIdentifier(
+      name: self.generateIdentifier(token),
+      nameLoc: self.generateSourceLoc(token)
+    )
+  }
+
+  /// Obtains bridged token source range from a pair of token nodes.
+  @inline(__always)
+  func generateSourceRange(start: TokenSyntax, end: TokenSyntax) -> BridgedSourceRange {
+    BridgedSourceRange(
+      start: self.generateSourceLoc(start),
+      end: self.generateSourceLoc(end)
+    )
+  }
+}
+
 extension ASTGenVisitor {
   /// Replaces the current declaration context with `declContext` for the duration of its execution, and calls `body`.
   @inline(__always)
diff --git a/lib/ASTGen/Sources/ASTGen/Bridge.swift b/lib/ASTGen/Sources/ASTGen/Bridge.swift
index d9601d6f8ede0..d1ea478d70534 100644
--- a/lib/ASTGen/Sources/ASTGen/Bridge.swift
+++ b/lib/ASTGen/Sources/ASTGen/Bridge.swift
@@ -78,13 +78,6 @@ public extension BridgedSourceLoc {
   }
 }
 
-extension BridgedSourceRange {
-  @inline(__always)
-  init(startToken: TokenSyntax, endToken: TokenSyntax, in astgen: ASTGenVisitor) {
-    self.init(start: startToken.bridgedSourceLoc(in: astgen), end: endToken.bridgedSourceLoc(in: astgen))
-  }
-}
-
 extension String {
   init(bridged: BridgedStringRef) {
     self.init(
@@ -141,9 +134,10 @@ extension SyntaxProtocol {
   /// Obtains the bridged start location of the node excluding leading trivia in the source buffer provided by `astgen`
   ///
   /// - Parameter astgen: The visitor providing the source buffer.
+  @available(*, deprecated, message: "use ASTContext.bridgedSourceLoc(syntax:)")
   @inline(__always)
   func bridgedSourceLoc(in astgen: ASTGenVisitor) -> BridgedSourceLoc {
-    return BridgedSourceLoc(at: self.positionAfterSkippingLeadingTrivia, in: astgen.base)
+    astgen.generateSourceLoc(self)
   }
 }
 
@@ -151,13 +145,10 @@ extension Optional where Wrapped: SyntaxProtocol {
   /// Obtains the bridged start location of the node excluding leading trivia in the source buffer provided by `astgen`.
   ///
   /// - Parameter astgen: The visitor providing the source buffer.
+  @available(*, deprecated, message: "use ASTContext.bridgedSourceLoc(syntax:)")
   @inline(__always)
   func bridgedSourceLoc(in astgen: ASTGenVisitor) -> BridgedSourceLoc {
-    guard let self else {
-      return nil
-    }
-
-    return self.bridgedSourceLoc(in: astgen)
+    astgen.generateSourceLoc(self)
   }
 }
 
@@ -165,31 +156,30 @@ extension TokenSyntax {
   /// Obtains a bridged, `ASTContext`-owned copy of this token's text.
   ///
   /// - Parameter astgen: The visitor providing the `ASTContext`.
+  @available(*, deprecated, message: "use ASTContext.bridgedIdentifier(token:)")
   @inline(__always)
   func bridgedIdentifier(in astgen: ASTGenVisitor) -> BridgedIdentifier {
-    var text = self.text
-    return text.withBridgedString { bridged in
-      astgen.ctx.getIdentifier(bridged)
-    }
+    astgen.generateIdentifier(self)
   }
 
   /// Obtains a bridged, `ASTContext`-owned copy of this token's text, and its bridged start location in the
   /// source buffer provided by `astgen`.
   ///
   /// - Parameter astgen: The visitor providing the `ASTContext` and source buffer.
+  @available(*, deprecated, message: "use ASTContext.bridgedIdentifierAndSourceLoc(token:)")
   @inline(__always)
   func bridgedIdentifierAndSourceLoc(in astgen: ASTGenVisitor) -> (BridgedIdentifier, BridgedSourceLoc) {
-    return (self.bridgedIdentifier(in: astgen), self.bridgedSourceLoc(in: astgen))
+    astgen.generateIdentifierAndSourceLoc(self)
   }
 
   /// Obtains a bridged, `ASTContext`-owned copy of this token's text, and its bridged start location in the
   /// source buffer provided by `astgen`.
   ///
   /// - Parameter astgen: The visitor providing the `ASTContext` and source buffer.
+  @available(*, deprecated, message: "use ASTContext.bridgedIdentifierAndSourceLoc(token:)")
   @inline(__always)
-  func bridgedIdentifierAndSourceLoc(in astgen: ASTGenVisitor) -> BridgedIdentifierAndSourceLoc {
-    let (name, nameLoc) = self.bridgedIdentifierAndSourceLoc(in: astgen)
-    return .init(name: name, nameLoc: nameLoc)
+  func bridgedIdentifierAndSourceLoc(in astgen: ASTGenVisitor) -> BridgedLocatedIdentifier {
+    astgen.generateLocatedIdentifier(self)
   }
 }
 
@@ -197,25 +187,27 @@ extension Optional<TokenSyntax> {
   /// Obtains a bridged, `ASTContext`-owned copy of this token's text.
   ///
   /// - Parameter astgen: The visitor providing the `ASTContext`.
+  @available(*, deprecated, message: "use ASTContext.bridgedIdentifier(token:)")
   @inline(__always)
   func bridgedIdentifier(in astgen: ASTGenVisitor) -> BridgedIdentifier {
-    guard let self else {
-      return nil
-    }
-
-    return self.bridgedIdentifier(in: astgen)
+    astgen.generateIdentifier(self)
   }
 
   /// Obtains a bridged, `ASTContext`-owned copy of this token's text, and its bridged start location in the
   /// source buffer provided by `astgen` excluding leading trivia.
   ///
   /// - Parameter astgen: The visitor providing the `ASTContext` and source buffer.
+  @available(*, deprecated, message: "use ASTContext.bridgedIdentifierAndSourceLoc(token:)")
   @inline(__always)
   func bridgedIdentifierAndSourceLoc(in astgen: ASTGenVisitor) -> (BridgedIdentifier, BridgedSourceLoc) {
-    guard let self else {
-      return (nil, nil)
-    }
+    astgen.generateIdentifierAndSourceLoc(self)
+  }
+}
 
-    return self.bridgedIdentifierAndSourceLoc(in: astgen)
+extension BridgedSourceRange {
+  @available(*, deprecated, message: "use ASTContext.bridgedSourceRange(startToken:endToken:)")
+  @inline(__always)
+  init(startToken: TokenSyntax, endToken: TokenSyntax, in astgen: ASTGenVisitor) {
+    self = astgen.generateSourceRange(start: startToken, end: endToken)
   }
 }
diff --git a/lib/ASTGen/Sources/ASTGen/Decls.swift b/lib/ASTGen/Sources/ASTGen/Decls.swift
index ae7357c0f1c4c..81210a9bd6b30 100644
--- a/lib/ASTGen/Sources/ASTGen/Decls.swift
+++ b/lib/ASTGen/Sources/ASTGen/Decls.swift
@@ -73,37 +73,36 @@ extension ASTGenVisitor {
   }
 
   public func generate(typeAliasDecl node: TypeAliasDeclSyntax) -> BridgedTypeAliasDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     return .createParsed(
       self.ctx,
       declContext: self.declContext,
-      typealiasKeywordLoc: node.typealiasKeyword.bridgedSourceLoc(in: self),
+      typealiasKeywordLoc: self.generateSourceLoc(node.typealiasKeyword),
       name: name,
       nameLoc: nameLoc,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
-      equalLoc: node.initializer.equal.bridgedSourceLoc(in: self),
+      equalLoc: self.generateSourceLoc(node.initializer.equal),
       underlyingType: self.generate(type: node.initializer.value),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause)
     )
   }
 
   public func generate(enumDecl node: EnumDeclSyntax) -> BridgedNominalTypeDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedEnumDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      enumKeywordLoc: node.enumKeyword.bridgedSourceLoc(in: self),
+      enumKeywordLoc: self.generateSourceLoc(node.enumKeyword),
       name: name,
       nameLoc: nameLoc,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      braceRange: BridgedSourceRange(
-        startToken: node.memberBlock.leftBrace,
-        endToken: node.memberBlock.rightBrace,
-        in: self
+      braceRange: self.generateSourceRange(
+        start: node.memberBlock.leftBrace,
+        end: node.memberBlock.rightBrace
       )
     )
 
@@ -115,21 +114,20 @@ extension ASTGenVisitor {
   }
 
   public func generate(structDecl node: StructDeclSyntax) -> BridgedNominalTypeDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedStructDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      structKeywordLoc: node.structKeyword.bridgedSourceLoc(in: self),
+      structKeywordLoc: self.generateSourceLoc(node.structKeyword),
       name: name,
       nameLoc: nameLoc,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      braceRange: BridgedSourceRange(
-        startToken: node.memberBlock.leftBrace,
-        endToken: node.memberBlock.rightBrace,
-        in: self
+      braceRange: self.generateSourceRange(
+        start: node.memberBlock.leftBrace,
+        end: node.memberBlock.rightBrace
       )
     )
 
@@ -141,21 +139,20 @@ extension ASTGenVisitor {
   }
 
   public func generate(classDecl node: ClassDeclSyntax) -> BridgedNominalTypeDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedClassDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      classKeywordLoc: node.classKeyword.bridgedSourceLoc(in: self),
+      classKeywordLoc: self.generateSourceLoc(node.classKeyword),
       name: name,
       nameLoc: nameLoc,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      braceRange: BridgedSourceRange(
-        startToken: node.memberBlock.leftBrace,
-        endToken: node.memberBlock.rightBrace,
-        in: self
+      braceRange: self.generateSourceRange(
+        start: node.memberBlock.leftBrace,
+        end: node.memberBlock.rightBrace
       ),
       isActor: false
     )
@@ -168,21 +165,20 @@ extension ASTGenVisitor {
   }
 
   public func generate(actorDecl node: ActorDeclSyntax) -> BridgedNominalTypeDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedClassDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      classKeywordLoc: node.actorKeyword.bridgedSourceLoc(in: self),
+      classKeywordLoc: self.generateSourceLoc(node.actorKeyword),
       name: name,
       nameLoc: nameLoc,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      braceRange: BridgedSourceRange(
-        startToken: node.memberBlock.leftBrace,
-        endToken: node.memberBlock.rightBrace,
-        in: self
+      braceRange: self.generateSourceRange(
+        start: node.memberBlock.leftBrace,
+        end: node.memberBlock.rightBrace
       ),
       isActor: true
     )
@@ -195,24 +191,23 @@ extension ASTGenVisitor {
   }
 
   func generate(protocolDecl node: ProtocolDeclSyntax) -> BridgedNominalTypeDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
     let primaryAssociatedTypeNames = node.primaryAssociatedTypeClause?.primaryAssociatedTypes.lazy.map {
-      $0.name.bridgedIdentifierAndSourceLoc(in: self) as BridgedIdentifierAndSourceLoc
+      self.generateLocatedIdentifier($0.name)
     }
 
     let decl = BridgedProtocolDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      protocolKeywordLoc: node.protocolKeyword.bridgedSourceLoc(in: self),
+      protocolKeywordLoc: self.generateSourceLoc(node.protocolKeyword),
       name: name,
       nameLoc: nameLoc,
       primaryAssociatedTypeNames: primaryAssociatedTypeNames.bridgedArray(in: self),
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      braceRange: BridgedSourceRange(
-        startToken: node.memberBlock.leftBrace,
-        endToken: node.memberBlock.rightBrace,
-        in: self
+      braceRange: self.generateSourceRange(
+        start: node.memberBlock.leftBrace,
+        end: node.memberBlock.rightBrace
       )
     )
 
@@ -224,12 +219,12 @@ extension ASTGenVisitor {
   }
 
   func generate(associatedTypeDecl node: AssociatedTypeDeclSyntax) -> BridgedAssociatedTypeDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     return .createParsed(
       self.ctx,
       declContext: self.declContext,
-      associatedtypeKeywordLoc: node.associatedtypeKeyword.bridgedSourceLoc(in: self),
+      associatedtypeKeywordLoc: self.generateSourceLoc(node.associatedtypeKeyword),
       name: name,
       nameLoc: nameLoc,
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
@@ -246,14 +241,13 @@ extension ASTGenVisitor {
     let decl = BridgedExtensionDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      extensionKeywordLoc: node.extensionKeyword.bridgedSourceLoc(in: self),
+      extensionKeywordLoc: self.generateSourceLoc(node.extensionKeyword),
       extendedType: self.generate(type: node.extendedType),
       inheritedTypes: self.generate(inheritedTypeList: node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      braceRange: BridgedSourceRange(
-        startToken: node.memberBlock.leftBrace,
-        endToken: node.memberBlock.rightBrace,
-        in: self
+      braceRange: self.generateSourceRange(
+        start: node.memberBlock.leftBrace,
+        end: node.memberBlock.rightBrace
       )
     )
 
@@ -269,7 +263,7 @@ extension ASTGenVisitor {
 
 extension ASTGenVisitor {
   func generate(enumCaseElement node: EnumCaseElementSyntax) -> BridgedEnumElementDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     return .createParsed(
       self.ctx,
@@ -277,7 +271,7 @@ extension ASTGenVisitor {
       name: name,
       nameLoc: nameLoc,
       parameterList: self.generate(enumCaseParameterClause: node.parameterClause),
-      equalsLoc: (node.rawValue?.equal).bridgedSourceLoc(in: self),
+      equalsLoc: self.generateSourceLoc(node.rawValue?.equal),
       rawValue: self.generate(expr: node.rawValue?.value)
     )
   }
@@ -285,7 +279,7 @@ extension ASTGenVisitor {
   func generate(enumCaseDecl node: EnumCaseDeclSyntax) -> BridgedEnumCaseDecl {
     .createParsed(
       declContext: self.declContext,
-      caseKeywordLoc: node.caseKeyword.bridgedSourceLoc(in: self),
+      caseKeywordLoc: self.generateSourceLoc(node.caseKeyword),
       elements: node.elements.lazy.map(self.generate).bridgedArray(in: self)
     )
   }
@@ -304,7 +298,7 @@ extension ASTGenVisitor {
     return .createParsed(
       self.ctx,
       declContext: self.declContext,
-      bindingKeywordLoc: node.bindingSpecifier.bridgedSourceLoc(in: self),
+      bindingKeywordLoc: self.generateSourceLoc(node.bindingSpecifier),
       pattern: pattern,
       initializer: initializer,
       isStatic: isStatic,
@@ -320,19 +314,19 @@ extension ASTGenVisitor {
     // FIXME: Compute this location
     let staticLoc: BridgedSourceLoc = nil
 
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     let decl = BridgedFuncDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
       staticLoc: staticLoc,
-      funcKeywordLoc: node.funcKeyword.bridgedSourceLoc(in: self),
+      funcKeywordLoc: self.generateSourceLoc(node.funcKeyword),
       name: name,
       nameLoc: nameLoc,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
       parameterList: self.generate(functionParameterClause: node.signature.parameterClause),
-      asyncSpecifierLoc: (node.signature.effectSpecifiers?.asyncSpecifier).bridgedSourceLoc(in: self),
-      throwsSpecifierLoc: (node.signature.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self),
+      asyncSpecifierLoc: self.generateSourceLoc(node.signature.effectSpecifiers?.asyncSpecifier),
+      throwsSpecifierLoc: self.generateSourceLoc(node.signature.effectSpecifiers?.throwsSpecifier),
       thrownType: self.generate(type: node.signature.effectSpecifiers?.thrownError),
       returnType: self.generate(type: node.signature.returnClause?.type),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause)
@@ -351,13 +345,13 @@ extension ASTGenVisitor {
     let decl = BridgedConstructorDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      initKeywordLoc: node.initKeyword.bridgedSourceLoc(in: self),
-      failabilityMarkLoc: node.optionalMark.bridgedSourceLoc(in: self),
+      initKeywordLoc: self.generateSourceLoc(node.initKeyword),
+      failabilityMarkLoc: self.generateSourceLoc(node.optionalMark),
       isIUO: node.optionalMark?.tokenKind == .exclamationMark,
       genericParamList: self.generate(genericParameterClause: node.genericParameterClause),
       parameterList: self.generate(functionParameterClause: node.signature.parameterClause),
-      asyncSpecifierLoc: (node.signature.effectSpecifiers?.asyncSpecifier).bridgedSourceLoc(in: self),
-      throwsSpecifierLoc: (node.signature.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self),
+      asyncSpecifierLoc: self.generateSourceLoc(node.signature.effectSpecifiers?.asyncSpecifier),
+      throwsSpecifierLoc: self.generateSourceLoc(node.signature.effectSpecifiers?.throwsSpecifier),
       thrownType: self.generate(type: node.signature.effectSpecifiers?.thrownError),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause)
     )
@@ -375,7 +369,7 @@ extension ASTGenVisitor {
     let decl = BridgedDestructorDecl.createParsed(
       self.ctx,
       declContext: self.declContext,
-      deinitKeywordLoc: node.deinitKeyword.bridgedSourceLoc(in: self)
+      deinitKeywordLoc: self.generateSourceLoc(node.deinitKeyword)
     )
 
     if let body = node.body {
@@ -403,9 +397,9 @@ extension BridgedOperatorFixity {
 
 extension ASTGenVisitor {
   func generate(operatorDecl node: OperatorDeclSyntax) -> BridgedOperatorDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
-    let (precedenceGroupName, precedenceGroupLoc) = (node.operatorPrecedenceAndTypes?.precedenceGroup)
-      .bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
+    let (precedenceGroupName, precedenceGroupLoc) =
+        self.generateIdentifierAndSourceLoc(node.operatorPrecedenceAndTypes?.precedenceGroup)
 
     let fixity: BridgedOperatorFixity
     if let value = BridgedOperatorFixity(from: node.fixitySpecifier.tokenKind) {
@@ -421,10 +415,10 @@ extension ASTGenVisitor {
       self.ctx,
       declContext: self.declContext,
       fixity: fixity,
-      operatorKeywordLoc: node.operatorKeyword.bridgedSourceLoc(in: self),
+      operatorKeywordLoc: self.generateSourceLoc(node.operatorKeyword),
       name: name,
       nameLoc: nameLoc,
-      colonLoc: (node.operatorPrecedenceAndTypes?.colon).bridgedSourceLoc(in: self),
+      colonLoc: self.generateSourceLoc(node.operatorPrecedenceAndTypes?.colon),
       precedenceGroupName: precedenceGroupName,
       precedenceGroupLoc: precedenceGroupLoc
     )
@@ -446,7 +440,7 @@ extension BridgedAssociativity {
 
 extension ASTGenVisitor {
   func generate(precedenceGroupDecl node: PrecedenceGroupDeclSyntax) -> BridgedPrecedenceGroupDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     struct PrecedenceGroupBody {
       var associativity: PrecedenceGroupAssociativitySyntax? = nil
@@ -522,21 +516,21 @@ extension ASTGenVisitor {
 
     return .createParsed(
       declContext: self.declContext,
-      precedencegroupKeywordLoc: node.precedencegroupKeyword.bridgedSourceLoc(in: self),
+      precedencegroupKeywordLoc: self.generateSourceLoc(node.precedencegroupKeyword),
       name: name,
       nameLoc: nameLoc,
-      leftBraceLoc: node.leftBrace.bridgedSourceLoc(in: self),
-      associativityLabelLoc: (body.associativity?.associativityLabel).bridgedSourceLoc(in: self),
-      associativityValueLoc: (body.associativity?.value).bridgedSourceLoc(in: self),
+      leftBraceLoc: self.generateSourceLoc(node.leftBrace),
+      associativityLabelLoc: self.generateSourceLoc(body.associativity?.associativityLabel),
+      associativityValueLoc: self.generateSourceLoc(body.associativity?.value),
       associativity: associativityValue,
-      assignmentLabelLoc: (body.assignment?.assignmentLabel).bridgedSourceLoc(in: self),
-      assignmentValueLoc: (body.assignment?.value).bridgedSourceLoc(in: self),
+      assignmentLabelLoc: self.generateSourceLoc(body.assignment?.assignmentLabel),
+      assignmentValueLoc: self.generateSourceLoc((body.assignment?.value)),
       isAssignment: assignmentValue,
-      higherThanKeywordLoc: (body.higherThanRelation?.higherThanOrLowerThanLabel).bridgedSourceLoc(in: self),
+      higherThanKeywordLoc: self.generateSourceLoc((body.higherThanRelation?.higherThanOrLowerThanLabel)),
       higherThanNames: self.generate(precedenceGroupNameList: body.higherThanRelation?.precedenceGroups),
-      lowerThanKeywordLoc: (body.lowerThanRelation?.higherThanOrLowerThanLabel).bridgedSourceLoc(in: self),
+      lowerThanKeywordLoc: self.generateSourceLoc(body.lowerThanRelation?.higherThanOrLowerThanLabel),
       lowerThanNames: self.generate(precedenceGroupNameList: body.lowerThanRelation?.precedenceGroups),
-      rightBraceLoc: node.rightBrace.bridgedSourceLoc(in: self)
+      rightBraceLoc: self.generateSourceLoc(node.rightBrace)
     )
   }
 }
@@ -575,11 +569,11 @@ extension ASTGenVisitor {
     return .createParsed(
       self.ctx,
       declContext: self.declContext,
-      importKeywordLoc: node.importKeyword.bridgedSourceLoc(in: self),
+      importKeywordLoc: self.generateSourceLoc(node.importKeyword),
       importKind: importKind,
-      importKindLoc: node.importKindSpecifier.bridgedSourceLoc(in: self),
+      importKindLoc: self.generateSourceLoc(node.importKindSpecifier),
       path: node.path.lazy.map {
-        $0.name.bridgedIdentifierAndSourceLoc(in: self) as BridgedIdentifierAndSourceLoc
+        self.generateLocatedIdentifier($0.name)
       }.bridgedArray(in: self)
     )
   }
@@ -599,7 +593,7 @@ extension ASTGenVisitor {
   @inline(__always)
   func generate(precedenceGroupNameList node: PrecedenceGroupNameListSyntax) -> BridgedArrayRef {
     node.lazy.map {
-      $0.name.bridgedIdentifierAndSourceLoc(in: self) as BridgedIdentifierAndSourceLoc
+      self.generateLocatedIdentifier($0.name)
     }.bridgedArray(in: self)
   }
 }
diff --git a/lib/ASTGen/Sources/ASTGen/Exprs.swift b/lib/ASTGen/Sources/ASTGen/Exprs.swift
index 219a832475068..f84bc749c92d4 100644
--- a/lib/ASTGen/Sources/ASTGen/Exprs.swift
+++ b/lib/ASTGen/Sources/ASTGen/Exprs.swift
@@ -205,8 +205,8 @@ extension ASTGenVisitor {
     let thrownTypeExpr: BridgedNullableExpr
 
     if let effectSpecifiers = node.effectSpecifiers {
-      asyncLoc = effectSpecifiers.asyncSpecifier.bridgedSourceLoc(in: self)
-      throwsLoc = (effectSpecifiers.throwsClause?.throwsSpecifier).bridgedSourceLoc(in: self)
+      asyncLoc = self.generateSourceLoc(effectSpecifiers.asyncSpecifier)
+      throwsLoc = self.generateSourceLoc(effectSpecifiers.throwsClause?.throwsSpecifier)
       if let thrownTypeNode = effectSpecifiers.thrownError {
         let typeExpr = BridgedTypeExpr.createParsed(
           self.ctx,
@@ -227,12 +227,12 @@ extension ASTGenVisitor {
       asyncLoc: asyncLoc,
       throwsLoc: throwsLoc,
       thrownType: thrownTypeExpr,
-      arrowLoc: node.arrow.bridgedSourceLoc(in: self)
+      arrowLoc: self.generateSourceLoc(node.arrow)
     )
   }
 
   public func generate(assignmentExpr node: AssignmentExprSyntax) -> BridgedAssignExpr {
-    return .createParsed(self.ctx, equalsLoc: node.equal.bridgedSourceLoc(in: self))
+    return .createParsed(self.ctx, equalsLoc: self.generateSourceLoc(node.equal))
   }
 
   public func generate(binaryOperatorExpr node: BinaryOperatorExprSyntax) -> BridgedUnresolvedDeclRefExpr {
@@ -242,9 +242,9 @@ extension ASTGenVisitor {
   public func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {
     let body = BridgedBraceStmt.createParsed(
       self.ctx,
-      lBraceLoc: node.leftBrace.bridgedSourceLoc(in: self),
+      lBraceLoc: self.generateSourceLoc(node.leftBrace),
       elements: self.generate(codeBlockItemList: node.statements),
-      rBraceLoc: node.rightBrace.bridgedSourceLoc(in: self)
+      rBraceLoc: self.generateSourceLoc(node.rightBrace)
     )
 
     // FIXME: Translate the signature, capture list, 'in' location, etc.
@@ -300,16 +300,16 @@ extension ASTGenVisitor {
     case .keyword(.subscript):
       baseName = .createSubscript()
     default:
-      baseName = .createIdentifier(node.baseName.bridgedIdentifier(in: self))
+      baseName = .createIdentifier(self.generateIdentifier(node.baseName))
     }
-    let baseNameLoc = node.baseName.bridgedSourceLoc(in: self)
+    let baseNameLoc = self.generateSourceLoc(node.baseName)
 
     if let argumentClause = node.argumentNames {
       let labels = argumentClause.arguments.lazy.map {
-        $0.name.bridgedIdentifier(in: self)
+        self.generateIdentifier($0.name)
       }
       let labelLocs = argumentClause.arguments.lazy.map {
-        $0.name.bridgedSourceLoc(in: self)
+        self.generateSourceLoc($0.name)
       }
       return (
         name: .createParsed(
@@ -320,9 +320,9 @@ extension ASTGenVisitor {
         loc: .createParsed(
           self.ctx,
           baseNameLoc: baseNameLoc,
-          lParenLoc: argumentClause.leftParen.bridgedSourceLoc(in: self),
+          lParenLoc: self.generateSourceLoc(argumentClause.leftParen),
           argumentLabelLocs: labelLocs.bridgedArray(in: self),
-          rParenLoc: argumentClause.rightParen.bridgedSourceLoc(in: self)
+          rParenLoc: self.generateSourceLoc(argumentClause.rightParen)
         )
       )
     } else {
@@ -344,7 +344,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(discardAssignmentExpr node: DiscardAssignmentExprSyntax) -> BridgedDiscardAssignmentExpr {
-    return .createParsed(self.ctx, loc: node.wildcard.bridgedSourceLoc(in: self))
+    return .createParsed(self.ctx, loc: self.generateSourceLoc(node.wildcard))
   }
 
   public func generate(memberAccessExpr node: MemberAccessExprSyntax) -> BridgedExpr {
@@ -354,14 +354,14 @@ extension ASTGenVisitor {
       return BridgedUnresolvedDotExpr.createParsed(
         self.ctx,
         base: self.generate(expr: base),
-        dotLoc: node.period.bridgedSourceLoc(in: self),
+        dotLoc: self.generateSourceLoc(node.period),
         name: nameAndLoc.name,
         nameLoc: nameAndLoc.loc
       ).asExpr
     } else {
       return BridgedUnresolvedMemberExpr.createParsed(
         self.ctx,
-        dotLoc: node.period.bridgedSourceLoc(in: self),
+        dotLoc: self.generateSourceLoc(node.period),
         name: nameAndLoc.name,
         nameLoc: nameAndLoc.loc
       ).asExpr
@@ -471,7 +471,7 @@ extension ASTGenVisitor {
 
   public func generate(unresolvedAsExpr node: UnresolvedAsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedExpr {
     let type = self.generate(type: typeNode.type)
-    let asLoc = node.asKeyword.bridgedSourceLoc(in: self)
+    let asLoc = self.generateSourceLoc(node.asKeyword)
 
     switch node.questionOrExclamationMark {
     case nil:
@@ -484,14 +484,14 @@ extension ASTGenVisitor {
       return BridgedConditionalCheckedCastExpr.createParsed(
         self.ctx,
         asLoc: asLoc,
-        questionLoc: question.bridgedSourceLoc(in: self),
+        questionLoc: self.generateSourceLoc(question),
         type: type
       ).asExpr
     case let exclaim? where exclaim.text == "!":
       return BridgedForcedCheckedCastExpr.createParsed(
         self.ctx,
         asLoc: asLoc,
-        exclaimLoc: exclaim.bridgedSourceLoc(in: self),
+        exclaimLoc: self.generateSourceLoc(exclaim),
         type: type
       ).asExpr
     case _?:
@@ -502,7 +502,7 @@ extension ASTGenVisitor {
   public func generate(unresolvedIsExpr node: UnresolvedIsExprSyntax, typeExpr typeNode: TypeExprSyntax) -> BridgedIsExpr {
     return .createParsed(
       self.ctx,
-      isLoc: node.isKeyword.bridgedSourceLoc(in: self),
+      isLoc: self.generateSourceLoc(node.isKeyword),
       type: self.generate(type: typeNode.type)
     )
   }
@@ -510,9 +510,9 @@ extension ASTGenVisitor {
   public func generate(unresolvedTernaryExpr node: UnresolvedTernaryExprSyntax) -> BridgedTernaryExpr {
     return .createParsed(
       self.ctx,
-      questionLoc: node.questionMark.bridgedSourceLoc(in: self),
+      questionLoc: self.generateSourceLoc(node.questionMark),
       thenExpr: self.generate(expr: node.thenExpression),
-      colonLoc: node.colon.bridgedSourceLoc(in: self)
+      colonLoc: self.generateSourceLoc(node.colon)
     )
   }
 
@@ -521,7 +521,7 @@ extension ASTGenVisitor {
 
 extension ASTGenVisitor {
   fileprivate func createOperatorRefExpr(token node: TokenSyntax, kind: BridgedDeclRefKind) -> BridgedUnresolvedDeclRefExpr {
-    let (name, nameLoc) = node.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node)
 
     return .createParsed(
       self.ctx,
@@ -538,23 +538,23 @@ extension ASTGenVisitor {
       self.generate(expr: $0.expression)
     }
     let labels = node.lazy.map {
-      $0.label.bridgedIdentifier(in: self)
+      self.generateIdentifier($0.label)
     }
     let labelLocations = node.lazy.map {
       if let label = $0.label {
-        return label.bridgedSourceLoc(in: self)
+        return self.generateSourceLoc(label)
       }
 
-      return $0.bridgedSourceLoc(in: self)
+      return self.generateSourceLoc($0)
     }
 
     return BridgedTupleExpr.createParsed(
       self.ctx,
-      leftParenLoc: leftParen.bridgedSourceLoc(in: self),
+      leftParenLoc: self.generateSourceLoc(leftParen),
       exprs: expressions.bridgedArray(in: self),
       labels: labels.bridgedArray(in: self),
       labelLocs: labelLocations.bridgedArray(in: self),
-      rightParenLoc: rightParen.bridgedSourceLoc(in: self)
+      rightParenLoc: self.generateSourceLoc(rightParen)
     )
   }
 }
diff --git a/lib/ASTGen/Sources/ASTGen/Generics.swift b/lib/ASTGen/Sources/ASTGen/Generics.swift
index 15bf1f3acb0c1..1e4845f342b38 100644
--- a/lib/ASTGen/Sources/ASTGen/Generics.swift
+++ b/lib/ASTGen/Sources/ASTGen/Generics.swift
@@ -17,15 +17,15 @@ extension ASTGenVisitor {
   func generate(genericParameterClause node: GenericParameterClauseSyntax) -> BridgedGenericParamList {
     .createParsed(
       self.ctx,
-      leftAngleLoc: node.leftAngle.bridgedSourceLoc(in: self),
+      leftAngleLoc: self.generateSourceLoc(node.leftAngle),
       parameters: node.parameters.lazy.map(self.generate).bridgedArray(in: self),
       genericWhereClause: self.generate(genericWhereClause: node.genericWhereClause),
-      rightAngleLoc: node.rightAngle.bridgedSourceLoc(in: self)
+      rightAngleLoc: self.generateSourceLoc(node.rightAngle)
     )
   }
 
   func generate(genericParameter node: GenericParameterSyntax) -> BridgedGenericTypeParamDecl {
-    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
     var genericParameterIndex: Int?
     for (index, sibling) in (node.parent?.as(GenericParameterListSyntax.self) ?? []).enumerated() {
@@ -41,7 +41,7 @@ extension ASTGenVisitor {
     return .createParsed(
       self.ctx,
       declContext: self.declContext,
-      eachKeywordLoc: node.eachKeyword.bridgedSourceLoc(in: self),
+      eachKeywordLoc: self.generateSourceLoc(node.eachKeyword),
       name: name,
       nameLoc: nameLoc,
       inheritedType: self.generate(type: node.inheritedType),
@@ -54,14 +54,14 @@ extension ASTGenVisitor {
       switch $0.requirement {
       case .conformanceRequirement(let conformance):
         return BridgedRequirementRepr(
-          SeparatorLoc: conformance.colon.bridgedSourceLoc(in: self),
+          SeparatorLoc: self.generateSourceLoc(conformance.colon),
           Kind: .typeConstraint,
           FirstType: self.generate(type: conformance.leftType),
           SecondType: self.generate(type: conformance.rightType)
         )
       case .sameTypeRequirement(let sameType):
         return BridgedRequirementRepr(
-          SeparatorLoc: sameType.equal.bridgedSourceLoc(in: self),
+          SeparatorLoc: self.generateSourceLoc(sameType.equal),
           Kind: .sameType,
           FirstType: self.generate(type: sameType.leftType),
           SecondType: self.generate(type: sameType.rightType)
@@ -74,7 +74,7 @@ extension ASTGenVisitor {
 
     return BridgedTrailingWhereClause.createParsed(
       self.ctx,
-      whereKeywordLoc: node.whereKeyword.bridgedSourceLoc(in: self),
+      whereKeywordLoc: self.generateSourceLoc(node.whereKeyword),
       requirements: requirements.bridgedArray(in: self)
     )
   }
diff --git a/lib/ASTGen/Sources/ASTGen/LegacyParse.swift b/lib/ASTGen/Sources/ASTGen/LegacyParse.swift
index a043272f1b627..7cc64457979fe 100644
--- a/lib/ASTGen/Sources/ASTGen/LegacyParse.swift
+++ b/lib/ASTGen/Sources/ASTGen/LegacyParse.swift
@@ -24,26 +24,26 @@ extension ASTGenVisitor {
 
     // FIXME: Calculate isExprBasic.
     let isExprBasic = false
-    return legacyParse.parseExpr(node.bridgedSourceLoc(in: self), self.declContext, isExprBasic)
+    return legacyParse.parseExpr(self.generateSourceLoc(node), self.declContext, isExprBasic)
   }
 
   func generateWithLegacy(_ node: DeclSyntax) -> BridgedDecl {
-    legacyParse.parseDecl(node.bridgedSourceLoc(in: self), self.declContext)
+    legacyParse.parseDecl(self.generateSourceLoc(node), self.declContext)
   }
 
   func generateWithLegacy(_ node: StmtSyntax) -> BridgedStmt {
-    legacyParse.parseStmt(node.bridgedSourceLoc(in: self), self.declContext)
+    legacyParse.parseStmt(self.generateSourceLoc(node), self.declContext)
   }
 
   func generateWithLegacy(_ node: TypeSyntax) -> BridgedTypeRepr {
-    legacyParse.parseType(node.bridgedSourceLoc(in: self), self.declContext)
+    legacyParse.parseType(self.generateSourceLoc(node), self.declContext)
   }
 
   func generateMatchingPatternWithLegacy(_ node: some PatternSyntaxProtocol) {
-//    legacyParse.parseMatchingPattern(node.bridgedSourceLoc(in: self), self.declContext)
+//    legacyParse.parseMatchingPattern(self.bridgedSourceLoc(syntax: node), self.declContext)
   }
 
   func generateBindingPatternWithLegacy(_ node: some PatternSyntaxProtocol) {
-//    legacyParse.parseBindingPattern(node.bridgedSourceLoc(in: self), self.declContext)
+//    legacyParse.parseBindingPattern(self.bridgedSourceLoc(syntax: node), self.declContext)
   }
 }
diff --git a/lib/ASTGen/Sources/ASTGen/Literals.swift b/lib/ASTGen/Sources/ASTGen/Literals.swift
index 73d3482500d4b..ba6d13c64afea 100644
--- a/lib/ASTGen/Sources/ASTGen/Literals.swift
+++ b/lib/ASTGen/Sources/ASTGen/Literals.swift
@@ -15,7 +15,7 @@ import SwiftSyntax
 
 extension ASTGenVisitor {
   public func generate(stringLiteralExpr node: StringLiteralExprSyntax) -> BridgedStringLiteralExpr {
-    let openDelimiterOrQuoteLoc = (node.openingPounds ?? node.openingQuote).bridgedSourceLoc(in: self)
+    let openDelimiterOrQuoteLoc = self.generateSourceLoc(node.openingPounds ?? node.openingQuote)
 
     // FIXME: Handle interpolated strings.
     // FIXME: Avoid 'String' instantiation
@@ -30,32 +30,43 @@ extension ASTGenVisitor {
     // FIXME: Strip '_'.
     var segment = node.literal.text
     return segment.withBridgedString { bridgedSegment in
-      return .createParsed(ctx, value: bridgedSegment, loc: node.literal.bridgedSourceLoc(in: self))
+      return .createParsed(
+        ctx,
+        value: bridgedSegment,
+        loc: self.generateSourceLoc(node.literal)
+      )
     }
   }
 
   public func generate(booleanLiteralExpr node: BooleanLiteralExprSyntax) -> BridgedBooleanLiteralExpr {
     let value = node.literal.tokenKind == .keyword(.true)
-    return .createParsed(ctx, value: value, loc: node.literal.bridgedSourceLoc(in: self))
+    return .createParsed(
+      ctx,
+      value: value,
+      loc: self.generateSourceLoc(node.literal)
+    )
   }
 
   public func generate(arrayExpr node: ArrayExprSyntax) -> BridgedArrayExpr {
     let expressions = node.elements.lazy.map(self.generate)
 
     let commaLocations = node.elements.compactMap(in: self) {
-      $0.trailingComma.bridgedSourceLoc(in: self)
+      self.generateSourceLoc($0.trailingComma)
     }
 
     return .createParsed(
       self.ctx,
-      lSquareLoc: node.leftSquare.bridgedSourceLoc(in: self),
+      lSquareLoc: self.generateSourceLoc(node.leftSquare),
       elements: expressions.bridgedArray(in: self),
       commaLocs: commaLocations,
-      rSquareLoc: node.rightSquare.bridgedSourceLoc(in: self)
+      rSquareLoc: self.generateSourceLoc(node.rightSquare)
     )
   }
 
   func generate(nilLiteralExpr node: NilLiteralExprSyntax) -> BridgedNilLiteralExpr {
-    .createParsed(self.ctx, nilKeywordLoc: node.nilKeyword.bridgedSourceLoc(in: self))
+    .createParsed(
+      self.ctx,
+      nilKeywordLoc: self.generateSourceLoc(node.nilKeyword)
+    )
   }
 }
diff --git a/lib/ASTGen/Sources/ASTGen/ParameterClause.swift b/lib/ASTGen/Sources/ASTGen/ParameterClause.swift
index 189bbf21da788..8181e24ecd361 100644
--- a/lib/ASTGen/Sources/ASTGen/ParameterClause.swift
+++ b/lib/ASTGen/Sources/ASTGen/ParameterClause.swift
@@ -73,22 +73,17 @@ extension ASTGenVisitor {
     // FIXME: This location should be derived from the type repr.
     let specifierLoc: BridgedSourceLoc = nil
 
-    let firstName: BridgedIdentifier
-    if node.optionalFirstName?.tokenKind == .wildcard {
-      // Swift AST represents "_" as a null identifier.
-      firstName = nil
-    } else {
-      firstName = node.optionalFirstName.bridgedIdentifier(in: self)
-    }
-
-    let (secondName, secondNameLoc) = node.secondName.bridgedIdentifierAndSourceLoc(in: self)
+    let (firstName, firstNameLoc) =
+        self.generateIdentifierAndSourceLoc(node.optionalFirstName)
+    let (secondName, secondNameLoc) =
+        self.generateIdentifierAndSourceLoc(node.secondName)
 
     var type = node.optionalType.map(generate(type:))
     if let ellipsis = node.ellipsis, let base = type {
       type = BridgedVarargTypeRepr.createParsed(
         self.ctx,
         base: base,
-        ellipsisLoc: ellipsis.bridgedSourceLoc(in: self)
+        ellipsisLoc: self.generateSourceLoc(ellipsis)
       )
     }
 
@@ -97,7 +92,7 @@ extension ASTGenVisitor {
       declContext: self.declContext,
       specifierLoc: specifierLoc,
       firstName: firstName,
-      firstNameLoc: node.optionalFirstName.bridgedSourceLoc(in: self),
+      firstNameLoc: firstNameLoc,
       secondName: secondName,
       secondNameLoc: secondNameLoc,
       type: type.asNullable,
@@ -112,18 +107,18 @@ extension ASTGenVisitor {
   func generate(functionParameterClause node: FunctionParameterClauseSyntax) -> BridgedParameterList {
     BridgedParameterList.createParsed(
       self.ctx,
-      leftParenLoc: node.leftParen.bridgedSourceLoc(in: self),
+      leftParenLoc: self.generateSourceLoc(node.leftParen),
       parameters: self.generate(functionParameterList: node.parameters),
-      rightParenLoc: node.rightParen.bridgedSourceLoc(in: self)
+      rightParenLoc: self.generateSourceLoc(node.rightParen)
     )
   }
 
   func generate(enumCaseParameterClause node: EnumCaseParameterClauseSyntax) -> BridgedParameterList {
     BridgedParameterList.createParsed(
       self.ctx,
-      leftParenLoc: node.leftParen.bridgedSourceLoc(in: self),
+      leftParenLoc: self.generateSourceLoc(node.leftParen),
       parameters: node.parameters.lazy.map(self.generate).bridgedArray(in: self),
-      rightParenLoc: node.rightParen.bridgedSourceLoc(in: self)
+      rightParenLoc: self.generateSourceLoc(node.rightParen)
     )
   }
 }
diff --git a/lib/ASTGen/Sources/ASTGen/Patterns.swift b/lib/ASTGen/Sources/ASTGen/Patterns.swift
index d2cad631ed7c0..cfa5183159a6a 100644
--- a/lib/ASTGen/Sources/ASTGen/Patterns.swift
+++ b/lib/ASTGen/Sources/ASTGen/Patterns.swift
@@ -38,7 +38,7 @@ extension ASTGenVisitor {
   }
 
   func generate(identifierPattern node: IdentifierPatternSyntax) -> BridgedNamedPattern {
-    let (name, nameLoc) = node.identifier.bridgedIdentifierAndSourceLoc(in: self)
+    let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.identifier)
     return .createParsed(
       ctx, declContext: declContext,
       name: name,
diff --git a/lib/ASTGen/Sources/ASTGen/Stmts.swift b/lib/ASTGen/Sources/ASTGen/Stmts.swift
index 3dafb8c57b9b0..c803e3203b230 100644
--- a/lib/ASTGen/Sources/ASTGen/Stmts.swift
+++ b/lib/ASTGen/Sources/ASTGen/Stmts.swift
@@ -57,9 +57,9 @@ extension ASTGenVisitor {
   public func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {
     BridgedBraceStmt.createParsed(
       self.ctx,
-      lBraceLoc: node.leftBrace.bridgedSourceLoc(in: self),
+      lBraceLoc: self.generateSourceLoc(node.leftBrace),
       elements: self.generate(codeBlockItemList: node.statements),
-      rBraceLoc: node.rightBrace.bridgedSourceLoc(in: self)
+      rBraceLoc: self.generateSourceLoc(node.rightBrace)
     )
   }
 
@@ -71,10 +71,10 @@ extension ASTGenVisitor {
 
     return .createParsed(
       self.ctx,
-      ifKeywordLoc: node.ifKeyword.bridgedSourceLoc(in: self),
+      ifKeywordLoc: self.generateSourceLoc(node.ifKeyword),
       condition: conditions.first!.castToExpr,
       thenStmt: self.generate(codeBlock: node.body),
-      elseLoc: node.elseKeyword.bridgedSourceLoc(in: self),
+      elseLoc: self.generateSourceLoc(node.elseKeyword),
       elseStmt: node.elseBody.map {
         switch $0 {
         case .codeBlock(let node):
@@ -98,7 +98,7 @@ extension ASTGenVisitor {
   public func generate(returnStmt node: ReturnStmtSyntax) -> BridgedReturnStmt {
     .createParsed(
       self.ctx,
-      returnKeywordLoc: node.returnKeyword.bridgedSourceLoc(in: self),
+      returnKeywordLoc: self.generateSourceLoc(node.returnKeyword),
       expr: self.generate(expr: node.expression)
     )
   }
diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift
index d6e61e1169dc4..906349f0f64f8 100644
--- a/lib/ASTGen/Sources/ASTGen/Types.swift
+++ b/lib/ASTGen/Sources/ASTGen/Types.swift
@@ -103,14 +103,14 @@ extension ASTGenVisitor {
   }
 
   public func generate(identifierType node: IdentifierTypeSyntax) -> BridgedTypeRepr {
-    let loc = node.bridgedSourceLoc(in: self)
+    let loc = self.generateSourceLoc(node.name)
 
     // If this is the bare 'Any' keyword, produce an empty composition type.
-    if node.name.tokenKind == .keyword(.Any) && node.genericArgumentClause == nil {
+    if node.name.rawText == "Any" && node.genericArgumentClause == nil {
       return BridgedCompositionTypeRepr.createEmpty(self.ctx, anyKeywordLoc: loc)
     }
 
-    let id = node.name.bridgedIdentifier(in: self)
+    let id = self.generateIdentifier(node.name)
 
     guard let generics = node.genericArgumentClause else {
       return BridgedSimpleIdentTypeRepr.createParsed(ctx, loc: loc, name: id)
@@ -125,8 +125,8 @@ extension ASTGenVisitor {
       name: id,
       nameLoc: loc,
       genericArgs: genericArguments.bridgedArray(in: self),
-      leftAngleLoc: generics.leftAngle.bridgedSourceLoc(in: self),
-      rightAngleLoc: generics.rightAngle.bridgedSourceLoc(in: self)
+      leftAngleLoc: self.generateSourceLoc(generics.leftAngle),
+      rightAngleLoc: self.generateSourceLoc(generics.rightAngle)
     )
   }
 
@@ -136,7 +136,7 @@ extension ASTGenVisitor {
 
     var baseType = TypeSyntax(node)
     while let memberType = baseType.as(MemberTypeSyntax.self) {
-      let (name, nameLoc) = memberType.name.bridgedIdentifierAndSourceLoc(in: self)
+      let (name, nameLoc) = self.generateIdentifierAndSourceLoc(node.name)
 
       if let generics = memberType.genericArgumentClause {
         let genericArguments = generics.arguments.lazy.map {
@@ -149,8 +149,8 @@ extension ASTGenVisitor {
             name: name,
             nameLoc: nameLoc,
             genericArgs: genericArguments.bridgedArray(in: self),
-            leftAngleLoc: generics.leftAngle.bridgedSourceLoc(in: self),
-            rightAngleLoc: generics.rightAngle.bridgedSourceLoc(in: self)
+            leftAngleLoc: self.generateSourceLoc(generics.leftAngle),
+            rightAngleLoc: self.generateSourceLoc(generics.rightAngle)
           )
         )
       } else {
@@ -174,8 +174,8 @@ extension ASTGenVisitor {
 
   public func generate(arrayType node: ArrayTypeSyntax) -> BridgedTypeRepr {
     let elementType = generate(type: node.element)
-    let lSquareLoc = node.leftSquare.bridgedSourceLoc(in: self)
-    let rSquareLoc = node.rightSquare.bridgedSourceLoc(in: self)
+    let lSquareLoc = self.generateSourceLoc(node.leftSquare)
+    let rSquareLoc = self.generateSourceLoc(node.rightSquare)
     return BridgedArrayTypeRepr.createParsed(
       self.ctx,
       base: elementType,
@@ -185,11 +185,11 @@ extension ASTGenVisitor {
   }
 
   public func generate(dictionaryType node: DictionaryTypeSyntax) -> BridgedTypeRepr {
-    let keyType = generate(type: node.key)
-    let valueType = generate(type: node.value)
-    let colonLoc = node.colon.bridgedSourceLoc(in: self)
-    let lSquareLoc = node.leftSquare.bridgedSourceLoc(in: self)
-    let rSquareLoc = node.rightSquare.bridgedSourceLoc(in: self)
+    let keyType = self.generate(type: node.key)
+    let valueType = self.generate(type: node.value)
+    let colonLoc = self.generateSourceLoc(node.colon)
+    let lSquareLoc = self.generateSourceLoc(node.leftSquare)
+    let rSquareLoc = self.generateSourceLoc(node.rightSquare)
     return BridgedDictionaryTypeRepr.createParsed(
       self.ctx,
       leftSquareLoc: lSquareLoc,
@@ -202,7 +202,7 @@ extension ASTGenVisitor {
 
   public func generate(metatypeType node: MetatypeTypeSyntax) -> BridgedTypeRepr {
     let baseType = generate(type: node.baseType)
-    let tyLoc = node.metatypeSpecifier.bridgedSourceLoc(in: self)
+    let tyLoc = self.generateSourceLoc(node.metatypeSpecifier)
     if node.metatypeSpecifier.rawText == "Type" {
       return BridgedMetatypeTypeRepr.createParsed(
         self.ctx,
@@ -221,7 +221,7 @@ extension ASTGenVisitor {
 
   public func generate(implicitlyUnwrappedOptionalType node: ImplicitlyUnwrappedOptionalTypeSyntax) -> BridgedTypeRepr {
     let base = generate(type: node.wrappedType)
-    let exclaimLoc = node.exclamationMark.bridgedSourceLoc(in: self)
+    let exclaimLoc = self.generateSourceLoc(node.exclamationMark)
     return BridgedImplicitlyUnwrappedOptionalTypeRepr.createParsed(
       self.ctx,
       base: base,
@@ -231,7 +231,7 @@ extension ASTGenVisitor {
 
   public func generate(optionalType node: OptionalTypeSyntax) -> BridgedTypeRepr {
     let base = generate(type: node.wrappedType)
-    let questionLoc = node.questionMark.bridgedSourceLoc(in: self)
+    let questionLoc = self.generateSourceLoc(node.questionMark)
     return BridgedOptionalTypeRepr.createParsed(
       self.ctx,
       base: base,
@@ -241,7 +241,7 @@ extension ASTGenVisitor {
 
   public func generate(packExpansionType node: PackExpansionTypeSyntax) -> BridgedTypeRepr {
     let base = generate(type: node.repetitionPattern)
-    let repeatLoc = node.repeatKeyword.bridgedSourceLoc(in: self)
+    let repeatLoc = self.generateSourceLoc(node.repeatKeyword)
     return BridgedPackExpansionTypeRepr.createParsed(
       self.ctx,
       base: base,
@@ -253,8 +253,8 @@ extension ASTGenVisitor {
     BridgedTupleTypeRepr.createParsed(
       self.ctx,
       elements: self.generate(tupleTypeElementList: node.elements),
-      leftParenLoc: node.leftParen.bridgedSourceLoc(in: self),
-      rightParenLoc: node.rightParen.bridgedSourceLoc(in: self)
+      leftParenLoc: self.generateSourceLoc(node.leftParen),
+      rightParenLoc: self.generateSourceLoc(node.rightParen)
     )
   }
 
@@ -268,7 +268,7 @@ extension ASTGenVisitor {
     return BridgedCompositionTypeRepr.createParsed(
       self.ctx,
       types: types.bridgedArray(in: self),
-      ampersandLoc: (node.elements.first?.ampersand).bridgedSourceLoc(in: self)
+      ampersandLoc: self.generateSourceLoc(node.elements.first?.ampersand)
     )
   }
 
@@ -279,13 +279,13 @@ extension ASTGenVisitor {
       argsType: BridgedTupleTypeRepr.createParsed(
         self.ctx,
         elements: self.generate(tupleTypeElementList: node.parameters),
-        leftParenLoc: node.leftParen.bridgedSourceLoc(in: self),
-        rightParenLoc: node.rightParen.bridgedSourceLoc(in: self)
+        leftParenLoc: self.generateSourceLoc(node.leftParen),
+        rightParenLoc: self.generateSourceLoc(node.rightParen)
       ),
-      asyncLoc: (node.effectSpecifiers?.asyncSpecifier).bridgedSourceLoc(in: self),
-      throwsLoc: (node.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self),
+      asyncLoc: self.generateSourceLoc(node.effectSpecifiers?.asyncSpecifier),
+      throwsLoc: self.generateSourceLoc(node.effectSpecifiers?.throwsSpecifier),
       thrownType: self.generate(type: node.effectSpecifiers?.thrownError),
-      arrowLoc: node.returnClause.arrow.bridgedSourceLoc(in: self),
+      arrowLoc: self.generateSourceLoc(node.returnClause.arrow),
       resultType: generate(type: node.returnClause.type)
     )
   }
@@ -296,7 +296,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(someOrAnyType node: SomeOrAnyTypeSyntax) -> BridgedTypeRepr {
-    let someOrAnyLoc = node.someOrAnySpecifier.bridgedSourceLoc(in: self)
+    let someOrAnyLoc = self.generateSourceLoc(node.someOrAnySpecifier)
     let baseTy = generate(type: node.constraint)
     if node.someOrAnySpecifier.rawText == "some" {
       return BridgedOpaqueReturnTypeRepr.createParsed(
@@ -345,7 +345,7 @@ extension ASTGenVisitor {
           self.ctx,
           base: type,
           specifier: kind,
-          specifierLoc: specifier.bridgedSourceLoc(in: self)
+          specifierLoc: self.generateSourceLoc(specifier)
         )
       } else {
         self.diagnose(Diagnostic(node: specifier, message: UnexpectedTokenKindError(token: specifier)))
@@ -369,8 +369,8 @@ extension ASTGenVisitor {
 
         let nameSyntax = identType.name
         let typeAttrKind = BridgedTypeAttrKind(from: nameSyntax.rawText.bridged)
-        let atLoc = attribute.atSign.bridgedSourceLoc(in: self)
-        let attrLoc = nameSyntax.bridgedSourceLoc(in: self)
+        let atLoc = self.generateSourceLoc(attribute.atSign)
+        let attrLoc = self.generateSourceLoc(nameSyntax)
         switch typeAttrKind {
         // SIL attributes
         // FIXME: Diagnose if not in SIL mode? Or should that move to the
@@ -411,14 +411,15 @@ extension ASTGenVisitor {
 extension ASTGenVisitor {
   func generate(tupleTypeElementList node: TupleTypeElementListSyntax) -> BridgedArrayRef {
     node.lazy.map { element in
-      let (firstName, firstNameLoc) = element.firstName.bridgedIdentifierAndSourceLoc(in: self)
-      let (secondName, secondNameLoc) = element.secondName.bridgedIdentifierAndSourceLoc(in: self)
+      let (firstName, firstNameLoc) =
+          self.generateIdentifierAndSourceLoc(element.firstName)
+      let (secondName, secondNameLoc) =           self.generateIdentifierAndSourceLoc(element.secondName)
       var type = generate(type: element.type)
       if let ellipsis = element.ellipsis {
         type = BridgedVarargTypeRepr.createParsed(
           self.ctx,
           base: type,
-          ellipsisLoc: ellipsis.bridgedSourceLoc(in: self)
+          ellipsisLoc: self.generateSourceLoc(ellipsis)
         )
       }
 
@@ -428,9 +429,9 @@ extension ASTGenVisitor {
         SecondName: secondName,
         SecondNameLoc: secondNameLoc,
         UnderscoreLoc: nil, /*N.B. Only important for SIL*/
-        ColonLoc: element.colon.bridgedSourceLoc(in: self),
+        ColonLoc: self.generateSourceLoc(element.colon),
         Type: type,
-        TrailingCommaLoc: element.trailingComma.bridgedSourceLoc(in: self)
+        TrailingCommaLoc: self.generateSourceLoc(element.trailingComma)
       )
     }.bridgedArray(in: self)
   }