Unified: Add static name binding pass

shared/namebinding/codeql/namebinding/LocalNameBinding.qll

@@ -136,6 +136,12 @@ signature module LocalNameBindingInputSig<LocationSig Location> {
    * full control of scope resolution for specific types of references.
    */
   default predicate lookupStartsAt(AstNode n, AstNode scope) { none() }
+
+  /**
+   * Holds if the set of names available in `scope` is not known ahead of time,
+   * and thus any lookup chain that goes through `scope` may need to be reconciled at a later stage.
+   */
+  default predicate uncertainScope(AstNode scope) { none() }
 }
 
 /**
@@ -154,6 +160,8 @@ module LocalNameBinding<LocationSig Location, LocalNameBindingInputSig<Location>
       implicitDeclInScope(_, this)
       or
       isTopScope(this)
+      or
+      uncertainScope(this)
     }
   }
 
@@ -353,6 +361,27 @@ module LocalNameBinding<LocationSig Location, LocalNameBindingInputSig<Location>
     )
   }
 
+  /**
+   * Holds if `name`, when resolved from `lookup`, may resolve to one of the uncertain members of `scope`.
+   */
+  pragma[nomagic]
+  private predicate lookupInUncertainScope(string name, Scope lookup, Scope scope) {
+    lookupInScope(name, lookup, scope) and
+    uncertainScope(scope) and
+    not declInScope(_, name, scope) and
+    not implicitDeclInScope(name, scope)
+  }
+
+  /**
+   * Gets an uncertain scope that the given `accessCand` pair may resolve to.
+   */
+  AstNode getAnUncertainScope(AstNode access, string name) {
+    exists(Scope lookup |
+      accessCandInLookupScope(access, name, lookup) and
+      lookupInUncertainScope(name, lookup, result)
+    )
+  }
+
   cached
   private newtype TLocal =
     TExplicitLocal(AstNode definingNode, string name, AstNode scope) {

unified/extractor/src/languages/swift/swift.rs

@@ -158,12 +158,12 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         // swift-syntax does not distinguish the lexical integer/string forms
         // (hex/binary/octal, single- vs multi-line, raw): each is a single
         // `*LiteralExpr` kind, so one rule per literal type suffices.
-        rule!((integerLiteralExpr) => (int_literal)),
-        rule!((floatLiteralExpr) => (float_literal)),
-        rule!((booleanLiteralExpr) => (boolean_literal)),
-        rule!((nilLiteralExpr) => (builtin_expr)),
-        rule!((stringLiteralExpr) => (string_literal)),
-        rule!((regexLiteralExpr) => (regex_literal)),
+        rule!((integerLiteralExpr) @@node => (int_literal #{node})),
+        rule!((floatLiteralExpr) @@node => (float_literal #{node})),
+        rule!((booleanLiteralExpr) @@node => (boolean_literal #{node})),
+        rule!((nilLiteralExpr) @@node => (builtin_expr #{node})),
+        rule!((stringLiteralExpr) @@node => (string_literal #{node})),
+        rule!((regexLiteralExpr) @@node => (regex_literal #{node})),
         // ---- Names ----
         // A function reference spelled with argument labels (`f(x:y:z:)`) is a
         // `declReferenceExpr` carrying `argumentNames`. Mark it unsupported for
@@ -1014,9 +1014,13 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         // A named type (`Int`). `identifierType.name` is the type-name token.
         rule!((identifierType name: @@n) => (named_type_expr name: (identifier #{n}))),
         // A qualified type (`Outer.Inner`, `NSString.CompareOptions`). swift-syntax
-        // nests these as `memberType` nodes; we keep the whole dotted path as the
-        // opaque `named_type_expr` name.
-        rule!((memberType) @ty => (named_type_expr name: (identifier #{ty}))),
+        // nests these as `memberType` nodes; preserve the nesting in the
+        // named_type_expr qualifier field.
+        rule!(
+            (memberType baseType: @base name: @@name)
+            =>
+            (named_type_expr qualifier: {base} name: (identifier #{name}))
+        ),
         // Sugared types desugar to `generic_type_expr`: `T?` -> Optional<T>,
         // `[T]` -> Array<T>, `[K: V]` -> Dictionary<K, V>.
         rule!(

unified/extractor/tests/corpus/swift/types/qualified-type.output

@@ -0,0 +1,139 @@
+struct Outer {
+  struct Inner {
+    struct Deep {}
+  }
+}
+
+let value: Outer.Inner
+let nested: Outer.Inner.Deep
+
+---
+
+sourceFile
+  endOfFileToken: endOfFile
+  statements:
+    codeBlockItem
+      item:
+        structDecl
+          attributes:
+          name: identifier "Outer"
+          memberBlock:
+            memberBlock
+              leftBrace: {
+              rightBrace: }
+              members:
+                memberBlockItem
+                  decl:
+                    structDecl
+                      attributes:
+                      name: identifier "Inner"
+                      memberBlock:
+                        memberBlock
+                          leftBrace: {
+                          rightBrace: }
+                          members:
+                            memberBlockItem
+                              decl:
+                                structDecl
+                                  attributes:
+                                  name: identifier "Deep"
+                                  memberBlock:
+                                    memberBlock
+                                      leftBrace: {
+                                      rightBrace: }
+                                      members:
+                                  modifiers:
+                                  structKeyword: struct
+                      modifiers:
+                      structKeyword: struct
+          modifiers:
+          structKeyword: struct
+    codeBlockItem
+      item:
+        variableDecl
+          attributes:
+          modifiers:
+          bindingSpecifier: let
+          bindings:
+            patternBinding
+              pattern:
+                identifierPattern
+                  identifier: identifier "value"
+              typeAnnotation:
+                typeAnnotation
+                  colon: :
+                  type:
+                    memberType
+                      name: identifier "Inner"
+                      baseType:
+                        identifierType
+                          name: identifier "Outer"
+                      period: .
+    codeBlockItem
+      item:
+        variableDecl
+          attributes:
+          modifiers:
+          bindingSpecifier: let
+          bindings:
+            patternBinding
+              pattern:
+                identifierPattern
+                  identifier: identifier "nested"
+              typeAnnotation:
+                typeAnnotation
+                  colon: :
+                  type:
+                    memberType
+                      name: identifier "Deep"
+                      baseType:
+                        memberType
+                          name: identifier "Inner"
+                          baseType:
+                            identifierType
+                              name: identifier "Outer"
+                          period: .
+                      period: .
+
+---
+
+top_level
+  body:
+    block
+      stmt:
+        class_like_declaration
+          modifier: modifier "struct"
+          name: identifier "Outer"
+          member:
+            class_like_declaration
+              modifier: modifier "struct"
+              name: identifier "Inner"
+              member:
+                class_like_declaration
+                  modifier: modifier "struct"
+                  name: identifier "Deep"
+        variable_declaration
+          modifier: modifier "let"
+          pattern:
+            name_pattern
+              identifier: identifier "value"
+          type:
+            named_type_expr
+              qualifier:
+                named_type_expr
+                  name: identifier "Outer"
+              name: identifier "Inner"
+        variable_declaration
+          modifier: modifier "let"
+          pattern:
+            name_pattern
+              identifier: identifier "nested"
+          type:
+            named_type_expr
+              qualifier:
+                named_type_expr
+                  qualifier:
+                    named_type_expr
+                      name: identifier "Outer"
+                  name: identifier "Inner"
+              name: identifier "Deep"

unified/extractor/tests/corpus/swift/types/qualified-type.swift

@@ -0,0 +1,8 @@
+struct Outer {
+  struct Inner {
+    struct Deep {}
+  }
+}
+
+let value: Outer.Inner
+let nested: Outer.Inner.Deep

unified/ql/lib/codeql/unified/internal/FacadeAst.qll

@@ -17,6 +17,14 @@ module Unified {
         mod.getValue() = text
       )
     }
+
+    /** Gets the nearest enclosing class declaration, possibly this node itself. */
+    ClassLikeDeclaration getEnclosingClass() {
+      result = this
+      or
+      not this instanceof ClassLikeDeclaration and
+      result = this.getParent().getEnclosingClass()
+    }
   }
 
   /** The base class for all patterns. */