Unified: Add static name binding pass

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. */

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

@@ -184,79 +184,92 @@ private module LocalNameBindingInput implements LocalNameBindingInputSig<Locatio
     override AstNode getElse() { none() }
   }
 
-  additional predicate bindingContext(AstNode pattern, AstNode scope) {
+  additional predicate bindingContext(AstNode pattern, AstNode scope, AstNode declaration) {
     exists(SiblingShadowingDecl decl |
       scope = decl and
-      pattern = decl.getPattern()
+      pattern = decl.getPattern() and
+      declaration = decl
     )
     or
     exists(VariableDeclaration decl |
       not decl instanceof SiblingShadowingDecl and
       getChild(scope, _) = decl and
-      pattern = decl.getPattern()
+      pattern = decl.getPattern() and
+      declaration = decl
     )
     or
     exists(FunctionDeclaration func |
       getChild(scope, _) = func and
-      pattern = func.getName()
+      pattern = func.getName() and
+      declaration = func
     )
     or
     exists(Parameter param |
       scope = param.getParent() and // TODO: add SourceCallable and use .getParameter() instead
-      pattern = param.getPattern()
+      pattern = param.getPattern() and
+      declaration = param
     )
     or
     exists(CatchClause catch |
       scope = catch and // ensure both body and pattern are in scope
-      pattern = catch.getPattern()
+      pattern = catch.getPattern() and
+      declaration = catch
     )
     or
     exists(SwitchCase case |
       scope = case and // ensure both body and pattern are in scope
-      pattern = case.getPattern()
+      pattern = case.getPattern() and
+      declaration = case
     )
     or
     exists(ForEachStmt stmt |
       scope = stmt and // ensure both 'body' and 'guard' are in scope
-      pattern = stmt.getPattern()
+      pattern = stmt.getPattern() and
+      declaration = stmt
     )
     or
     exists(ClassLikeDeclaration cls |
       getChild(scope, _) = cls and
-      pattern = cls.getName()
+      pattern = cls.getName() and
+      declaration = cls
     )
     or
     exists(TypeAliasDeclaration decl |
       getChild(scope, _) = decl and
-      pattern = decl.getName()
+      pattern = decl.getName() and
+      declaration = decl
     )
     or
     exists(TypeParameter param |
       scope = param.getParent() and
-      pattern = param.getName()
+      pattern = param.getName() and
+      declaration = param
     )
     or
     exists(AssociatedTypeDeclaration decl |
       getChild(scope, _) = decl and
-      pattern = decl.getName()
+      pattern = decl.getName() and
+      declaration = decl
     )
     or
     exists(AccessorDeclaration decl |
       getChild(scope, _) = decl and
-      pattern = decl.getName()
+      pattern = decl.getName() and
+      declaration = decl
     )
     or
     exists(ImportDeclaration imprt |
       getChild(scope, _) = imprt and
-      pattern = imprt.getPattern()
+      pattern = imprt.getPattern() and
+      declaration = imprt
     )
     or
     exists(NamePattern p |
-      bindingContext(p, scope) and
+      bindingContext(p, scope, declaration) and
       pattern = p.getIdentifier()
     )
     or
-    bindingContext(pattern.(Pattern).getEnclosingPattern(), scope)
+    bindingContext(pattern.(Pattern).getEnclosingPattern(), scope, declaration)
   }
 
   /**
@@ -284,7 +297,7 @@ private module LocalNameBindingInput implements LocalNameBindingInputSig<Locatio
 
   predicate declInScope(AstNode definingNode, string name, AstNode scope) {
     exists(AstNode pattern |
-      bindingContext(pattern, scope) and
+      bindingContext(pattern, scope, _) and
       pattern.(Identifier).getValue() = name and
       (
         definingNode = getEnclosingOrPatternFromIdentifier(pattern)
@@ -303,6 +316,8 @@ private module LocalNameBindingInput implements LocalNameBindingInputSig<Locatio
   predicate accessCand(AstNode n, string name) { n.(PotentialLocalNameAccess).getName() = name }
 }
 
+import LocalNameBindingInput
+
 module LocalNameBindingOutput = LocalNameBinding<Location, LocalNameBindingInput>;
 
 module Public {
@@ -319,6 +334,20 @@ module Public {
     /** Gets the name of this local, as a string. */
     string getName() { result = super.getName() }
   }
+
+  /** An identifier that appears as the declaration site of a name, such as the `x` in `let x = 123`. */
+  class NameDeclaration extends Identifier {
+    NameDeclaration() { LocalNameBindingInput::bindingContext(this, _, _) }
+
+    /** Gets the statement-like node declaring this name, such as a `VariableDeclaration` or `CatchClause`. */
+    AstNode getDeclaration() { LocalNameBindingInput::bindingContext(this, _, result) }
+
+    /** Gets the name being declared. */
+    string getName() { result = this.getValue() }
+
+    /** Gets the representative for the local name introduced by this declaration. */
+    LocalName getLocalName() { result = this.(LocalNameBindingOutput::LocalAccess).getLocal() }
+  }
 }
 
 /**
@@ -342,13 +371,13 @@ class PotentialLocalNameAccess extends Identifier {
     or
     this = any(NamedTypeExpr e | not exists(e.getQualifier())).getName()
     or
-    LocalNameBindingInput::bindingContext(this, _)
+    this instanceof NameDeclaration
   }
 
   LocalName getLocalName() { result = this.(LocalNameBindingOutput::LocalAccess).getLocal() }
 
   string getName() { result = this.getValue() }
 
   /** Holds if this is one of the declaration sites for a name, such as the `x` in `let x = 123`. */
-  predicate isDeclarationSite() { LocalNameBindingInput::bindingContext(this, _) }
+  predicate isDeclarationSite() { this instanceof NameDeclaration }
 }