Doc

Author: rintaro

Sources/JExtractSwiftLib/SwiftTypes/SwiftTypeLookupContext.swift

@@ -15,68 +15,24 @@
 import SwiftSyntax
 @_spi(Experimental) import SwiftLexicalLookup
 
+/// Unqualified type lookup manager.
+/// All unqualified lookup should be done via this instance. This caches the
+/// association of `Syntax.ID` to `SwiftTypeDeclaration`, and guarantees that
+/// there's only one `SwiftTypeDeclaration` per declaration `Syntax`.
 class SwiftTypeLookupContext {
   var symbolTable: SwiftSymbolTable
 
-  var typeDecls: [Syntax.ID: SwiftTypeDeclaration] = [:]
+  private var typeDecls: [Syntax.ID: SwiftTypeDeclaration] = [:]
 
   init(symbolTable: SwiftSymbolTable) {
     self.symbolTable = symbolTable
   }
 
-  func typeDeclaration(for node: some SyntaxProtocol) throws -> SwiftTypeDeclaration? {
-    if let found = typeDecls[node.id] {
-      return found
-    }
-
-    let typeDecl: SwiftTypeDeclaration
-    switch Syntax(node).as(SyntaxEnum.self) {
-    case .genericParameter(let node):
-      typeDecl = SwiftGenericParameterDeclaration(moduleName: symbolTable.moduleName, node: node)
-    case .classDecl(let node):
-      typeDecl = try nominalTypeDeclaration(for: node)
-    case .actorDecl(let node):
-      typeDecl = try nominalTypeDeclaration(for: node)
-    case .structDecl(let node):
-      typeDecl = try nominalTypeDeclaration(for: node)
-    case .enumDecl(let node):
-      typeDecl = try nominalTypeDeclaration(for: node)
-    case .protocolDecl(let node):
-      typeDecl = try nominalTypeDeclaration(for: node)
-    case .typeAliasDecl:
-      fatalError("typealias not implemented")
-    case .associatedTypeDecl:
-      fatalError("associatedtype not implemented")
-    default:
-      throw TypeLookupError.notType(Syntax(node))
-    }
-
-    typeDecls[node.id] = typeDecl
-    return typeDecl
-  }
-
-  func parentTypeDecl(for node: some DeclSyntaxProtocol) throws -> SwiftNominalTypeDeclaration? {
-    var node: DeclSyntax = DeclSyntax(node)
-    while let parentDecl = node.ancestorDecl {
-      switch parentDecl.as(DeclSyntaxEnum.self) {
-      case .structDecl, .classDecl, .actorDecl, .enumDecl, .protocolDecl:
-        return (try typeDeclaration(for: parentDecl) as! SwiftNominalTypeDeclaration)
-      default:
-        node = parentDecl
-        continue
-      }
-    }
-    return nil
-  }
-
-  func nominalTypeDeclaration(for node: NominalTypeDeclSyntaxNode) throws -> SwiftNominalTypeDeclaration {
-    SwiftNominalTypeDeclaration(
-      moduleName: self.symbolTable.moduleName,
-      parent: try parentTypeDecl(for: node),
-      node: node
-    )
-  }
-
+  /// Perform unqualified type lookup.
+  ///
+  /// - Parameters:
+  ///   - name: name to lookup
+  ///   - node: `Syntax` node the lookup happened
   func unqualifiedLookup(name: Identifier, from node: some SyntaxProtocol) throws -> SwiftTypeDeclaration? {
 
     for result in node.lookup(name) {
@@ -113,6 +69,7 @@ class SwiftTypeLookupContext {
     return symbolTable.lookupTopLevelNominalType(name.name)
   }
 
+  /// Find the first type declaration in the `LookupName` results.
   func typeDeclaration(for names: [LookupName]) -> SwiftTypeDeclaration? {
     for name in names {
       switch name {
@@ -130,6 +87,63 @@ class SwiftTypeLookupContext {
     }
     return nil
   }
+
+  /// Returns the type declaration object associated with the `Syntax` node.
+  /// If there's no declaration created, create an instance on demand, and cache it.
+  private func typeDeclaration(for node: some SyntaxProtocol) throws -> SwiftTypeDeclaration? {
+    if let found = typeDecls[node.id] {
+      return found
+    }
+
+    let typeDecl: SwiftTypeDeclaration
+    switch Syntax(node).as(SyntaxEnum.self) {
+    case .genericParameter(let node):
+      typeDecl = SwiftGenericParameterDeclaration(moduleName: symbolTable.moduleName, node: node)
+    case .classDecl(let node):
+      typeDecl = try nominalTypeDeclaration(for: node)
+    case .actorDecl(let node):
+      typeDecl = try nominalTypeDeclaration(for: node)
+    case .structDecl(let node):
+      typeDecl = try nominalTypeDeclaration(for: node)
+    case .enumDecl(let node):
+      typeDecl = try nominalTypeDeclaration(for: node)
+    case .protocolDecl(let node):
+      typeDecl = try nominalTypeDeclaration(for: node)
+    case .typeAliasDecl:
+      fatalError("typealias not implemented")
+    case .associatedTypeDecl:
+      fatalError("associatedtype not implemented")
+    default:
+      throw TypeLookupError.notType(Syntax(node))
+    }
+
+    typeDecls[node.id] = typeDecl
+    return typeDecl
+  }
+
+  /// Create a nominal type declaration instance for the specified syntax node.
+  private func nominalTypeDeclaration(for node: NominalTypeDeclSyntaxNode) throws -> SwiftNominalTypeDeclaration {
+    SwiftNominalTypeDeclaration(
+      moduleName: self.symbolTable.moduleName,
+      parent: try parentTypeDecl(for: node),
+      node: node
+    )
+  }
+
+  /// Find a parent nominal type declaration of the specified syntax node.
+  private func parentTypeDecl(for node: some DeclSyntaxProtocol) throws -> SwiftNominalTypeDeclaration? {
+    var node: DeclSyntax = DeclSyntax(node)
+    while let parentDecl = node.ancestorDecl {
+      switch parentDecl.as(DeclSyntaxEnum.self) {
+      case .structDecl, .classDecl, .actorDecl, .enumDecl, .protocolDecl:
+        return (try typeDeclaration(for: parentDecl) as! SwiftNominalTypeDeclaration)
+      default:
+        node = parentDecl
+        continue
+      }
+    }
+    return nil
+  }
 }
 
 enum TypeLookupError: Error {