Switch from lookIn... to lookFor... naming scheme in LookupResult.

Author: MAJKFL

Sources/SwiftLexicalLookup/LookupResult.swift

@@ -17,7 +17,7 @@ public enum LookupResult {
   /// Scope and the names that matched lookup.
   case fromScope(Syntax, withNames: [LookupName])
   /// Indicates where to perform member lookup.
-  case lookInMembers(Syntax)
+  case lookForMembers(in: Syntax)
   /// Indicates to lookup generic parameters of extended type.
   ///
   /// ### Example
@@ -28,10 +28,10 @@ public enum LookupResult {
   ///   }
   /// }
   /// ```
-  /// For a lookup started at the marked position, `lookInGenericParametersOfExtendedType`
+  /// For a lookup started at the marked position, `lookForGenericParameters`
   /// will be included as one of the results prompting the client
   /// to lookup the generic parameters of of the extended `Foo` type.
-  case lookInGenericParametersOfExtendedType(ExtensionDeclSyntax)
+  case lookForGenericParameters(of: ExtensionDeclSyntax)
   /// Indicates this closure expression could introduce dollar identifiers.
   ///
   /// ### Example
@@ -43,22 +43,19 @@ public enum LookupResult {
   /// }
   /// ```
   /// When looking up for any identifier at the indicated position,
-  /// the result will include `mightIntroduceDollarIdentifiers`
-  /// result kind. If it's performed for a dollar identifier, `LookupName.dollarIdentifier`
-  /// with the appropriate identifier will be used in the
-  /// result associated with the closure expression inside `a`.
-  case mightIntroduceDollarIdentifiers(ClosureExprSyntax)
+  /// the result will include `lookForImplicitClosureParameters`.
+  case lookForImplicitClosureParameters(ClosureExprSyntax)
 
   /// Associated scope.
   public var scope: SyntaxProtocol {
     switch self {
     case .fromScope(let scopeSyntax, _):
       return scopeSyntax
-    case .lookInMembers(let lookInMemb):
+    case .lookForMembers(let lookInMemb):
       return lookInMemb
-    case .lookInGenericParametersOfExtendedType(let extensionDecl):
+    case .lookForGenericParameters(let extensionDecl):
       return extensionDecl
-    case .mightIntroduceDollarIdentifiers(let closureExpr):
+    case .lookForImplicitClosureParameters(let closureExpr):
       return closureExpr
     }
   }
@@ -68,9 +65,9 @@ public enum LookupResult {
     switch self {
     case .fromScope(_, let names):
       return names
-    case .lookInMembers(_),
-      .lookInGenericParametersOfExtendedType(_),
-      .mightIntroduceDollarIdentifiers(_):
+    case .lookForMembers(_),
+      .lookForGenericParameters(_),
+      .lookForImplicitClosureParameters(_):
       return []
     }
   }
@@ -90,7 +87,7 @@ public enum LookupResult {
       + ((Syntax(scope).asProtocol(SyntaxProtocol.self) as? ScopeSyntax)?.scopeDebugDescription ?? "NOT-A-SCOPE")
 
     switch self {
-    case .lookInMembers:
+    case .lookForMembers:
       break
     default:
       if !names.isEmpty {
@@ -114,12 +111,12 @@ public enum LookupResult {
     switch self {
     case .fromScope:
       return "fromScope"
-    case .lookInMembers:
-      return "lookInMembers"
-    case .lookInGenericParametersOfExtendedType(_):
-      return "lookInGenericParametersOfExtendedType"
-    case .mightIntroduceDollarIdentifiers(_):
-      return "mightIntroduceDollarIdentifiers"
+    case .lookForMembers:
+      return "lookForMembers"
+    case .lookForGenericParameters(_):
+      return "lookForGenericParameters"
+    case .lookForImplicitClosureParameters(_):
+      return "lookForImplicitClosureParameters"
     }
   }
 }

Sources/SwiftLexicalLookup/Scopes/NominalTypeDeclSyntax.swift

@@ -43,7 +43,7 @@ extension NominalTypeDeclSyntax {
     } else if name.range.contains(lookUpPosition) || genericWhereClause?.range.contains(lookUpPosition) ?? false {
       return lookupInParent(identifier, at: lookUpPosition, with: config)
     } else {
-      return [.lookInMembers(Syntax(self))] + lookupInParent(identifier, at: lookUpPosition, with: config)
+      return [.lookForMembers(in: Syntax(self))] + lookupInParent(identifier, at: lookUpPosition, with: config)
     }
   }
 }

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -191,7 +191,7 @@ import SwiftSyntax
 
       signatureResults =
         LookupResult.getResultArray(for: self, withNames: filteredCaptureNames)
-        + [.mightIntroduceDollarIdentifiers(self)]
+        + [.lookForImplicitClosureParameters(self)]
     } else {
       signatureResults = LookupResult.getResultArray(
         for: self,
@@ -414,21 +414,21 @@ import SwiftSyntax
         }
 
       return LookupResult.getResultArray(for: self, withNames: implicitSelf)
-        + [.lookInGenericParametersOfExtendedType(self)]
+        + [.lookForGenericParameters(of: self)]
         + defaultLookupImplementation(identifier, at: lookUpPosition, with: config, propagateToParent: false)
-        + [.lookInMembers(Syntax(self))]
+        + [.lookForMembers(in: Syntax(self))]
         + lookupInParent(identifier, at: lookUpPosition, with: config)
     } else if !extendedType.range.contains(lookUpPosition), let genericWhereClause {
       if genericWhereClause.range.contains(lookUpPosition) {
-        return [.lookInGenericParametersOfExtendedType(self)] + [.lookInMembers(Syntax(self))]
+        return [.lookForGenericParameters(of: self)] + [.lookForMembers(in: Syntax(self))]
           + defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
       }
 
-      return [.lookInGenericParametersOfExtendedType(self)]
+      return [.lookForGenericParameters(of: self)]
         + defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
     }
 
-    return [.lookInGenericParametersOfExtendedType(self)]
+    return [.lookForGenericParameters(of: self)]
       + lookupInParent(identifier, at: lookUpPosition, with: config)
   }
 }
@@ -715,7 +715,7 @@ import SwiftSyntax
     let lookInMembers: [LookupResult]
 
     if !(inheritanceClause?.range.contains(lookUpPosition) ?? false) {
-      lookInMembers = [.lookInMembers(Syntax(self))]
+      lookInMembers = [.lookForMembers(in: Syntax(self))]
     } else {
       lookInMembers = []
     }