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)
+      )
     )
   }
 
@@ -457,7 +461,12 @@ module Impl {
     VariableAccessCand cand, VariableScope scope, string name, int nestLevel, int ord
   ) {
     name = cand.getName() and
-    scope = [cand.(VariableScope), getEnclosingScope(cand)] and
+    (
+      scope = cand.(VariableScope)
+      or
+      not cand instanceof VariableScope and
+      scope = getEnclosingScope(cand)
+    ) and
     ord = getPreOrderNumbering(scope, cand) and
     nestLevel = 0
     or
@@ -470,6 +479,19 @@ module Impl {
     )
   }
 
+  private predicate testvariableAccessCandInScope(
+    VariableAccessCand cand, VariableScope scope, string name, int nestLevel, int ord
+  ) {
+    // variableAccessCandInScope(cand, scope, name, nestLevel, ord) and
+    cand.getLocation().getStartLine() = 770 and
+    (
+      name = cand.getName() and
+      scope = [cand.(VariableScope), getEnclosingScope(cand)] and
+      ord = getPreOrderNumbering(scope, cand) and
+      nestLevel = 0
+    )
+  }
+
   private newtype TDefOrAccessCand =
     TDefOrAccessCandNestedFunction(Function f, BlockExprScope scope) {
       f = scope.getStmtList().getAStatement()
@@ -647,6 +669,14 @@ module Impl {
     )
   }
 
+  private predicate testvariableReachesCand(
+    VariableScope scope, string name, NestedFunctionOrVariable v, VariableAccessCand cand,
+    int nestLevel
+  ) {
+    variableReachesCand(scope, name, v, cand, nestLevel) and
+    v.getLocation().getStartLine() = [767, 769]
+  }
+
   pragma[nomagic]
   predicate access(string name, NestedFunctionOrVariable v, VariableAccessCand cand) {
     v =
@@ -657,6 +687,11 @@ module Impl {
       )
   }
 
+  private predicate testaccess(string name, NestedFunctionOrVariable v, VariableAccessCand cand) {
+    access(name, v, cand) and
+    cand.getLocation().getStartLine() = 770
+  }
+
   /** A variable access. */
   class VariableAccess extends PathExprBaseImpl::PathExprBase {
     private string name;

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())
   }
 }