debug

Author: hvitved

rust/ql/lib/codeql/rust/elements/internal/AstNodeImpl.qll

@@ -29,6 +29,24 @@ module Impl {
     result = getImmediateParent(e)
   }
 
+  /**
+   * Holds if `n` is superseded by an attribute macro expansion. That is, `n` is
+   * an item or a transitive child of an item with an attribute macro expansion.
+   */
+  predicate supersededByAttributeMacroExpansion(AstNode n) {
+    n.(Item).hasAttributeMacroExpansion()
+    or
+    exists(AstNode parent |
+      n.getParentNode() = parent and
+      supersededByAttributeMacroExpansion(parent) and
+      // Don't exclude expansions themselves as they supercede other nodes.
+      not n = parent.(Item).getAttributeMacroExpansion() and
+      // Don't consider attributes themselves to be superseded.  E.g., in `#[a] fn
+      // f() {}` the macro expansion supercedes `fn f() {}` but not `#[a]`.
+      not n instanceof Attr
+    )
+  }
+
   class AstNode extends Generated::AstNode {
     /**
      * Gets the nearest enclosing parent of this node, which is also an `AstNode`,

rust/ql/lib/codeql/rust/elements/internal/VariableImpl.qll

@@ -2,6 +2,7 @@ private import rust
 private import codeql.rust.controlflow.ControlFlowGraph
 private import codeql.rust.internal.PathResolution as PathResolution
 private import codeql.rust.elements.internal.generated.ParentChild as ParentChild
+private import codeql.rust.elements.internal.AstNodeImpl::Impl as AstNodeImpl
 private import codeql.rust.elements.internal.PathImpl::Impl as PathImpl
 private import codeql.rust.elements.internal.PathExprBaseImpl::Impl as PathExprBaseImpl
 private import codeql.rust.elements.internal.FormatTemplateVariableAccessImpl::Impl as FormatTemplateVariableAccessImpl
@@ -104,29 +105,32 @@ module Impl {
   cached
   predicate variableDecl(AstNode definingNode, Name name, string text) {
     Cached::ref() and
-    exists(SelfParam sp |
-      name = sp.getName() and
-      definingNode = name and
-      text = name.getText() and
-      // exclude self parameters from functions without a body as these are
-      // trait method declarations without implementations
-      not exists(Function f | not f.hasBody() and f.getSelfParam() = sp)
-    )
-    or
-    exists(IdentPat pat |
-      name = pat.getName() and
-      (
-        definingNode = getOutermostEnclosingOrPat(pat)
-        or
-        not exists(getOutermostEnclosingOrPat(pat)) and definingNode = name
-      ) and
-      text = name.getText() and
-      not PathResolution::identPatIsResolvable(pat) and
-      // exclude parameters from functions without a body as these are trait method declarations
-      // without implementations
-      not exists(Function f | not f.hasBody() and f.getAParam().getPat() = pat) and
-      // exclude parameters from function pointer types (e.g. `x` in `fn(x: i32) -> i32`)
-      not exists(FnPtrTypeRepr fp | fp.getParamList().getAParam().getPat() = pat)
+    not AstNodeImpl::supersededByAttributeMacroExpansion(definingNode) and
+    (
+      exists(SelfParam sp |
+        name = sp.getName() and
+        definingNode = name and
+        text = name.getText() and
+        // exclude self parameters from functions without a body as these are
+        // trait method declarations without implementations
+        not exists(Function f | not f.hasBody() and f.getSelfParam() = sp)
+      )
+      or
+      exists(IdentPat pat |
+        name = pat.getName() and
+        (
+          definingNode = getOutermostEnclosingOrPat(pat)
+          or
+          not exists(getOutermostEnclosingOrPat(pat)) and definingNode = name
+        ) and
+        text = name.getText() and
+        not PathResolution::identPatIsResolvable(pat) and
+        // exclude parameters from functions without a body as these are trait method declarations
+        // without implementations
+        not exists(Function f | not f.hasBody() and f.getAParam().getPat() = pat) and
+        // exclude parameters from function pointer types (e.g. `x` in `fn(x: i32) -> i32`)
+        not exists(FnPtrTypeRepr fp | fp.getParamList().getAParam().getPat() = pat)
+      )
     )
   }
 

rust/ql/lib/codeql/rust/internal/Definitions.qll

@@ -17,8 +17,6 @@ private import codeql.rust.internal.PathResolution
 
 /** An element with an associated definition. */
 abstract class Use extends Locatable {
-  Use() { not this.(AstNode).isFromMacroExpansion() }
-
   /** Gets the definition associated with this element. */
   abstract Definition getDefinition();
 
@@ -37,14 +35,17 @@ private module Cached {
     TFormatArgsArgIndex(Expr e) { e = any(FormatArgsArg a).getExpr() } or
     TItemNode(ItemNode i)
 
+  pragma[nomagic]
+  private predicate isMacroCallLocation(Location loc) { loc = any(MacroCall m).getLocation() }
+
   /**
    * Gets an element, of kind `kind`, that element `use` uses, if any.
    */
   cached
   Definition definitionOf(Use use, string kind) {
     result = use.getDefinition() and
     kind = use.getUseType() and
-    not result.getLocation() = any(MacroCall m).getLocation()
+    not isMacroCallLocation(result.getLocation())
   }
 }
 

rust/ql/lib/codeql/rust/internal/PathResolution.qll

@@ -4,6 +4,7 @@
 
 private import rust
 private import codeql.rust.elements.internal.generated.ParentChild
+private import codeql.rust.elements.internal.AstNodeImpl::Impl as AstNodeImpl
 private import codeql.rust.elements.internal.CallExprImpl::Impl as CallExprImpl
 private import codeql.rust.internal.CachedStages
 private import codeql.rust.frameworks.stdlib.Builtins as Builtins
@@ -90,24 +91,6 @@ private module UseOption = Option<Use>;
 
 private class UseOption = UseOption::Option;
 
-/**
- * Holds if `n` is superseded by an attribute macro expansion. That is, `n` is
- * an item or a transitive child of an item with an attribute macro expansion.
- */
-predicate supersededByAttributeMacroExpansion(AstNode n) {
-  n.(Item).hasAttributeMacroExpansion()
-  or
-  exists(AstNode parent |
-    n.getParentNode() = parent and
-    supersededByAttributeMacroExpansion(parent) and
-    // Don't exclude expansions themselves as they supercede other nodes.
-    not n = parent.(Item).getAttributeMacroExpansion() and
-    // Don't consider attributes themselves to be superseded.  E.g., in `#[a] fn
-    // f() {}` the macro expansion supercedes `fn f() {}` but not `#[a]`.
-    not n instanceof Attr
-  )
-}
-
 /**
  * An item that may be referred to by a path, and which is a node in
  * the _item graph_.
@@ -188,7 +171,7 @@ predicate supersededByAttributeMacroExpansion(AstNode n) {
 abstract class ItemNode extends Locatable {
   ItemNode() {
     // Exclude items that are superseded by the expansion of an attribute macro.
-    not supersededByAttributeMacroExpansion(this)
+    not AstNodeImpl::supersededByAttributeMacroExpansion(this)
   }
 
   /** Gets the (original) name of this item. */
@@ -1531,6 +1514,8 @@ private predicate declares(ItemNode item, Namespace ns, string name) {
  * to constructors in patterns.
  */
 abstract class PathExt extends AstNode {
+  PathExt() { not AstNodeImpl::supersededByAttributeMacroExpansion(this) }
+
   abstract string getText();
 
   /** Holds if this is an unqualified path with the textual value `name`. */
@@ -1975,7 +1960,10 @@ private ItemNode resolvePathCand(PathExt path) {
         then result instanceof TypeItemNode
         else
           if path instanceof IdentPat
-          then result instanceof VariantItemNode or result instanceof StructItemNode
+          then
+            result instanceof VariantItemNode or
+            result instanceof StructItemNode or
+            result instanceof ConstItemNode
           else any()
   |
     pathUsesNamespace(path, ns)
@@ -2066,6 +2054,13 @@ private ItemNode resolveUseTreeListItem(Use use, UseTree tree, PathExt path, Suc
       result = q.getASuccessor(name, kind, useOpt)
     )
   )
+  // or
+  // // use {std::cmp::Ordering::*, AdjustmentHintsMode::*};
+  // tree = use.getUseTree() and
+  // not tree.hasPath() and
+  // isUseTreeSubPathUnqualified(tree, path, _) and
+  // result = resolvePathCand(path) and
+  // kind.isBoth() // todo
 }
 
 pragma[nomagic]
@@ -2093,6 +2088,7 @@ private ItemNode resolveUseTreeListItem(Use use, UseTree tree) {
     result = resolveUseTreeListItem(use, tree, path, _)
   )
   or
+  // use foo::{bar, *}
   exists(UseTree midTree |
     result = resolveUseTreeListItem(use, midTree) and
     tree = getAUseTreeUseTree(midTree) and
@@ -2217,8 +2213,12 @@ private module Debug {
   Locatable getRelevantLocatable() {
     exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
       result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
-      filepath.matches("%/main.rs") and
-      startline = 800
+      // filepath.matches("%/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs") and
+      // startline = [6, 227]
+      // filepath.matches("%/compiler/rustc_middle/src/ty/layout.rs") and
+      // startline = 36
+      filepath.matches("%/cranelift-codegen-943c3c0c33bda67e/out/isle_riscv64.rs") and
+      startline = 11
     )
   }
 
@@ -2233,9 +2233,14 @@ private module Debug {
     path = p.toStringDebug()
   }
 
+  ItemNode debugUnqualifiedPathLookup(PathExt p, Namespace ns, SuccessorKind kind) {
+    p = getRelevantLocatable() and
+    result = unqualifiedPathLookup(p, ns, kind)
+  }
+
   predicate debugItemNode(ItemNode item) { item = getRelevantLocatable() }
 
-  ItemNode debugResolvePath(PathExt path) {
+  ItemNode debugResolvePath(Path path) {
     path = getRelevantLocatable() and
     result = resolvePath(path)
   }

rust/ql/lib/utils/test/PathResolutionInlineExpectationsTest.qll

@@ -3,6 +3,7 @@
  */
 
 private import rust
+private import codeql.rust.elements.internal.AstNodeImpl::Impl as AstNodeImpl
 private import codeql.rust.internal.PathResolution
 private import codeql.rust.internal.TypeInference
 private import utils.test.InlineExpectationsTest
@@ -37,13 +38,15 @@ private module ResolveTest implements TestSig {
     )
   }
 
-  predicate hasActualResult(Location location, string element, string tag, string value) {
+  private predicate hasResult(
+    Location location, string element, string tag, string value, boolean inMacro
+  ) {
     exists(AstNode n |
       not n = any(Path parent).getQualifier() and
       location = n.getLocation() and
       n.fromSource() and
       not location.getFile().getAbsolutePath().matches("%proc_macro.rs") and
-      not n.isFromMacroExpansion() and
+      (if n.isFromMacroExpansion() then inMacro = true else inMacro = false) and
       element = n.toString() and
       tag = "item"
     |
@@ -52,6 +55,14 @@ private module ResolveTest implements TestSig {
       item(n.(MethodCallExpr).getStaticTarget(), value)
     )
   }
+
+  predicate hasActualResult(Location location, string element, string tag, string value) {
+    hasResult(location, element, tag, value, false)
+  }
+
+  predicate hasOptionalResult(Location location, string element, string tag, string value) {
+    hasResult(location, element, tag, value, true)
+  }
 }
 
 import MakeTest<ResolveTest>

rust/ql/test/library-tests/path-resolution/main.rs

@@ -813,6 +813,24 @@ mod patterns {
         let test = test_alias();
         test
     }
+
+    #[rustfmt::skip]
+    const z: i32 // $ item=i32
+        = 0; // constz
+
+    #[rustfmt::skip]
+    fn test3() {
+        let x = Some(0); // $ item=Some
+        match x {
+            Some(x) // $ item=Some
+                => x,
+            _ => 0
+        };
+        match x {
+            Some(z) => z, // $ item=Some item=constz
+            _ => 0
+        };
+    }
 }
 
 fn main() {