Rust: rework derived type paths

Author: Paolo Tranquilli

rust/extractor/src/generated/.generated.list

@@ -327,6 +327,31 @@ impl<'a> Translator<'a> {
             );
         }
     }
+
+    fn emit_derived_type_canonical_path<T: AsRef<str>>(
+        &mut self,
+        modifiers: &[T],
+        bases: Vec<Label<generated::TypeCanonicalPath>>,
+    ) -> Label<generated::TypeCanonicalPath> {
+        let modifiers = modifiers
+            .iter()
+            .map(|s| s.as_ref().to_owned())
+            .collect::<Vec<String>>();
+        let id = itertools::interleave(
+            modifiers.iter().cloned(),
+            bases.iter().map(|t| t.as_key_part()),
+        )
+        .join("")
+        .into();
+        self.trap
+            .emit(generated::DerivedTypeCanonicalPath {
+                id,
+                modifiers,
+                base: bases,
+            })
+            .into()
+    }
+
     fn canonical_path_from_type(
         &mut self,
         ty: Type,
@@ -368,41 +393,17 @@ impl<'a> Translator<'a> {
                     .into(),
             )
         } else if let Some((it, size)) = ty.as_array(sema.db) {
-            let modifier = format!("[{{0}}; {size}]");
-            let base = vec![self.canonical_path_from_type(it)?];
-            Some(
-                self.trap
-                    .emit(generated::DerivedTypeCanonicalPath {
-                        id: trap_key!(modifier, base),
-                        modifier,
-                        base,
-                    })
-                    .into(),
-            )
+            let modifiers = ["[".to_owned(), format!("; {size}]")];
+            let bases = vec![self.canonical_path_from_type(it)?];
+            Some(self.emit_derived_type_canonical_path(&modifiers, bases))
         } else if let Some(it) = ty.as_slice() {
-            let modifier = "[{0}]".to_owned();
-            let base = vec![self.canonical_path_from_type(it)?];
-            Some(
-                self.trap
-                    .emit(generated::DerivedTypeCanonicalPath {
-                        id: trap_key!(modifier, base),
-                        modifier,
-                        base,
-                    })
-                    .into(),
-            )
+            let modifiers = ["[", "]"];
+            let bases = vec![self.canonical_path_from_type(it)?];
+            Some(self.emit_derived_type_canonical_path(&modifiers, bases))
         } else if ty.is_unit() {
-            let modifier = "()".to_owned();
-            let base = vec![];
-            Some(
-                self.trap
-                    .emit(generated::DerivedTypeCanonicalPath {
-                        id: trap_key!(modifier, base),
-                        modifier,
-                        base,
-                    })
-                    .into(),
-            )
+            let modifiers = ["()"];
+            let bases = vec![];
+            Some(self.emit_derived_type_canonical_path(&modifiers, bases))
         } else if let Some(it) = ty.as_builtin() {
             let name = it.name().as_str().to_owned();
             Some(
@@ -414,20 +415,13 @@ impl<'a> Translator<'a> {
                     .into(),
             )
         } else if let Some((it, mutability)) = ty.as_reference() {
-            let modifier = format!("&{}{{0}}", mutability.as_keyword_for_ref());
-            let base = vec![self.canonical_path_from_type(it)?];
-            Some(
-                self.trap
-                    .emit(generated::DerivedTypeCanonicalPath {
-                        id: trap_key!(modifier, base),
-                        modifier,
-                        base,
-                    })
-                    .into(),
-            )
+            let modifiers = [format!("&{}", mutability.as_keyword_for_ref())];
+            let bases = vec![self.canonical_path_from_type(it)?];
+            Some(self.emit_derived_type_canonical_path(&modifiers, bases))
         } else if ty.as_type_param(sema.db).is_some() {
             // from the canonical path perspective, we just want a special name
             // e.g. `crate::<_ as SomeTrait>::func`
+            // TODO: This will not work for assigning trap keys to types themselves!
             Some(
                 self.trap
                     .emit(generated::PlaceholderTypeCanonicalPath { id: trap_key!("_") })
@@ -438,20 +432,15 @@ impl<'a> Translator<'a> {
             if tuple_args.is_empty() {
                 None
             } else {
-                let modifier = format!("({{{}}})", (0..tuple_args.len()).join("}, {"));
-                let base = tuple_args
+                let modifiers = std::iter::once("(")
+                    .chain(std::iter::repeat(", ").take(tuple_args.len() - 1))
+                    .chain(std::iter::once(")"))
+                    .collect::<Vec<_>>();
+                let bases = tuple_args
                     .into_iter()
                     .map(|arg| self.canonical_path_from_type(arg))
                     .collect::<Option<Vec<_>>>()?;
-                Some(
-                    self.trap
-                        .emit(generated::DerivedTypeCanonicalPath {
-                            id: trap_key!(modifier, base),
-                            modifier,
-                            base,
-                        })
-                        .into(),
-                )
+                Some(self.emit_derived_type_canonical_path(&modifiers, bases))
             }
         }
     }
@@ -712,11 +701,7 @@ impl<'a> Translator<'a> {
                 return None;
             };
             let path = self.canonical_path_from_module_def(def)?;
-            generated::Resolvable::emit_resolved_canonical_path(
-                label.into(),
-                path,
-                &mut self.trap.writer,
-            );
+            generated::Resolvable::emit_resolved_canonical_path(label, path, &mut self.trap.writer);
             Some(())
         })();
     }

rust/extractor/src/generated/mod.rs

@@ -16,10 +16,14 @@ module Impl {
    * A derived canonical type, like `[i32; 4]`, `&mut std::string::String` or `(i32, std::string::String)`.
    */
   class DerivedTypeCanonicalPath extends Generated::DerivedTypeCanonicalPath {
-    override string toString() {
-      result =
-        this.getModifier() + "(" +
-          strictconcat(int i | | this.getBase(i).toAbbreviatedString(), ", " order by i) + ")"
+    override string toString() { result = strictconcat(int i | | this.toStringPart(i) order by i) }
+
+    private string toStringPart(int index) {
+      exists(int j |
+        index = 2 * j and result = this.getModifier(j)
+        or
+        index = 2 * j + 1 and result = this.getBase(j).toAbbreviatedString()
+      )
     }
   }
 }

rust/extractor/src/translate/base.rs

@@ -3477,7 +3477,13 @@ concrete_type_canonical_paths(  //dir=canonical_paths
 );
 
 derived_type_canonical_paths(  //dir=canonical_paths
-  unique int id: @derived_type_canonical_path,
+  unique int id: @derived_type_canonical_path
+);
+
+#keyset[id, index]
+derived_type_canonical_path_modifiers(  //dir=canonical_paths
+  int id: @derived_type_canonical_path ref,
+  int index: int ref,
   string modifier: string ref
 );
 

rust/ql/.generated.list

@@ -58,6 +58,18 @@ canonicalPaths
 | regular.rs:102:1:104:1 | impl GenericTrait::<...> for GenericEnum::<...> { ... } | None |
 | regular.rs:103:5:103:39 | fn generic_method | <... as ...>::generic_method |
 | regular.rs:106:1:119:1 | fn generic_usage | ...::generic_usage |
+| regular.rs:121:1:123:1 | impl Trait for ... { ... } | None |
+| regular.rs:122:5:122:18 | fn f | <... as ...>::f |
+| regular.rs:125:1:127:1 | impl Trait for ... { ... } | None |
+| regular.rs:126:5:126:18 | fn f | <... as ...>::f |
+| regular.rs:129:1:131:1 | impl Trait for ... { ... } | None |
+| regular.rs:130:5:130:18 | fn f | <... as ...>::f |
+| regular.rs:133:1:135:1 | impl Trait for ... { ... } | None |
+| regular.rs:134:5:134:18 | fn f | <... as ...>::f |
+| regular.rs:137:1:139:1 | impl Trait for ... { ... } | None |
+| regular.rs:138:5:138:18 | fn f | <... as ...>::f |
+| regular.rs:141:1:147:1 | fn use_trait | ...::use_trait |
+| regular.rs:144:5:144:17 | vec!... | None |
 resolvedPaths
 | anonymous.rs:27:17:27:30 | OtherStruct {...} | None |
 | anonymous.rs:28:9:28:9 | s | None |
@@ -105,6 +117,14 @@ resolvedPaths
 | regular.rs:117:13:117:37 | ...::U | ...::U |
 | regular.rs:118:5:118:5 | x | None |
 | regular.rs:118:5:118:23 | ... .generic_method(...) | <... as ...>::generic_method |
+| regular.rs:142:5:142:10 | ... .f(...) | <... as ...>::f |
+| regular.rs:143:5:143:15 | ... .f(...) | <... as ...>::f |
+| regular.rs:144:5:144:17 | ...::into_vec | <...>::into_vec |
+| regular.rs:144:5:144:17 | ...::new | None |
+| regular.rs:144:5:144:28 | ... .as_slice(...) | <...>::as_slice |
+| regular.rs:144:5:144:32 | ... .f(...) | <... as ...>::f |
+| regular.rs:145:5:145:16 | ... .f(...) | <... as ...>::f |
+| regular.rs:146:5:146:20 | ... .f(...) | <... as ...>::f |
 resolve
 | regular.rs:27:13:27:21 | Struct {...} | regular.rs:1:1:2:18 | struct Struct |
 | regular.rs:28:5:28:9 | ... .f(...) | regular.rs:9:5:9:18 | fn f |
@@ -133,3 +153,8 @@ resolve
 | regular.rs:116:5:116:27 | ... .generic_method(...) | regular.rs:99:5:99:37 | fn generic_method |
 | regular.rs:117:13:117:37 | ...::U | regular.rs:79:5:79:8 | U |
 | regular.rs:118:5:118:23 | ... .generic_method(...) | regular.rs:103:5:103:39 | fn generic_method |
+| regular.rs:142:5:142:10 | ... .f(...) | regular.rs:122:5:122:18 | fn f |
+| regular.rs:143:5:143:15 | ... .f(...) | regular.rs:126:5:126:18 | fn f |
+| regular.rs:144:5:144:32 | ... .f(...) | regular.rs:130:5:130:18 | fn f |
+| regular.rs:145:5:145:16 | ... .f(...) | regular.rs:134:5:134:18 | fn f |
+| regular.rs:146:5:146:20 | ... .f(...) | regular.rs:138:5:138:18 | fn f |

rust/ql/lib/codeql/rust/elements/canonical_paths/internal/DerivedTypeCanonicalPathImpl.qll

@@ -117,3 +117,31 @@ fn generic_usage() {
     let x = GenericEnum::<&str, _>::U(0);
     x.generic_method(1);
 }
+
+impl Trait for () {
+    fn f(&self) {}
+}
+
+impl Trait for (i32, &str) {
+    fn f(&self) {}
+}
+
+impl Trait for [i32] {
+    fn f(&self) {}
+}
+
+impl Trait for [&str; 2] {
+    fn f(&self) {}
+}
+
+impl Trait for [&str; 3] {
+    fn f(&self) {}
+}
+
+fn use_trait() {
+    ().f();
+    (0, "").f();
+    vec![0, 1, 2].as_slice().f();
+    ["", ""].f();
+    ["", "", ""].f();
+}