Merge pull request #18445 from hvitved/rust/format-args-index

Rust: Remove `Format.getArgument`

rust/ql/lib/codeql/rust/AstConsistency.qll

@@ -52,6 +52,27 @@ query predicate multipleParents(Element child, string childClass, Element parent
   parentClass = parent.getPrimaryQlClasses()
 }
 
+/** Holds if `parent` has multiple children at the same index. */
+query predicate multipleChildren(Element parent, int index, Element child1, Element child2) {
+  child1 = getChildAndAccessor(parent, index, _) and
+  child2 = getChildAndAccessor(parent, index, _) and
+  child1 != child2
+}
+
+/**
+ * Holds if `child` has multiple positions amongst the `accessor` children
+ * of `parent`.
+ *
+ * Children are allowed to have multiple positions for _different_ accessors,
+ * for example in an array repeat expression `[1; 10]`, `1` has positions for
+ * both `getRepeatOperand()` and `getExpr()`.
+ */
+query predicate multiplePositions(Element parent, int pos1, int pos2, string accessor, Element child) {
+  child = getChildAndAccessor(parent, pos1, accessor) and
+  child = getChildAndAccessor(parent, pos2, accessor) and
+  pos1 != pos2
+}
+
 /**
  * Gets counts of abstract syntax tree inconsistencies of each type.
  */
@@ -71,4 +92,10 @@ int getAstInconsistencyCounts(string type) {
   or
   type = "Multiple parents" and
   result = count(Element e | multipleParents(e) | e)
+  or
+  type = "Multiple children" and
+  result = count(Element e | multipleChildren(_, _, e, _) | e)
+  or
+  type = "Multiple positions" and
+  result = count(Element e | multiplePositions(_, _, _, _, e) | e)
 }

rust/ql/lib/codeql/rust/controlflow/CfgNodes.qll

@@ -195,8 +195,9 @@ final class FormatArgsExprCfgNode extends Nodes::FormatArgsExprCfgNode {
 
   /** Gets a format argument of the `i`th format of this format arguments expression (0-based). */
   FormatTemplateVariableAccessCfgNode getFormatTemplateVariableAccess(int i) {
-    exists(FormatTemplateVariableAccess v |
-      v.getArgument() = node.getFormat(i).getArgument() and
+    exists(FormatTemplateVariableAccess v, Format f |
+      f = node.getFormat(i) and
+      v.getArgument() = [f.getArgumentRef(), f.getWidthArgument(), f.getPrecisionArgument()] and
       result.getFormatTemplateVariableAccess() = v and
       any(ChildMapping mapping).hasCfgChild(node, v, this, result)
     )

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

@@ -42,41 +42,15 @@ module Impl {
 
     override int getIndex() { result = index }
 
-    override FormatArgument getArgument() { result.getParent() = this }
-
-    /**
-     * Gets the name or position reference of this format, if any. For example `name` and `0` in:
-     * ```rust
-     * let name = "Alice";
-     * println!("{name} in wonderland");
-     * println!("{0} in wonderland", name);
-     * ```
-     */
-    FormatArgument getArgumentRef() {
+    override FormatArgument getArgumentRef() {
       result.getParent() = this and result = Synth::TFormatArgument(_, _, 0, _, _, _)
     }
 
-    /**
-     * Gets the name or position reference of the width parameter in this format, if any. For example `width` and `1` in:
-     * ```rust
-     * let width = 6;
-     * println!("{:width$}", PI);
-     * println!("{:1$}", PI, width);
-     * ```
-     */
-    FormatArgument getWidthArgument() {
+    override FormatArgument getWidthArgument() {
       result.getParent() = this and result = Synth::TFormatArgument(_, _, 1, _, _, _)
     }
 
-    /**
-     * Gets the name or position reference of the width parameter in this format, if any. For example `prec` and `1` in:
-     * ```rust
-     * let prec = 6;
-     * println!("{:.prec$}", PI);
-     * println!("{:.1$}", PI, prec);
-     * ```
-     */
-    FormatArgument getPrecisionArgument() {
+    override FormatArgument getPrecisionArgument() {
       result.getParent() = this and result = Synth::TFormatArgument(_, _, 2, _, _, _)
     }
   }