Bazel: regenerate vendored cargo dependencies

Author: paldepind

MODULE.bazel

@@ -145,7 +145,7 @@ use_repo(
     "vendor_ts__tracing-flame-0.2.0",
     "vendor_ts__tracing-subscriber-0.3.20",
     "vendor_ts__tree-sitter-0.24.6",
-    "vendor_ts__tree-sitter-embedded-template-0.25.0",
+    "vendor_ts__tree-sitter-embedded-template-0.23.2",
     "vendor_ts__tree-sitter-json-0.24.8",
     "vendor_ts__tree-sitter-ql-0.23.1",
     "vendor_ts__tree-sitter-ruby-0.23.1",

misc/bazel/3rdparty/tree_sitter_extractors_deps/BUILD.bazel

@@ -0,0 +1,134 @@
+
+  signature module SubstitutionSig2 {
+    class TypeAbstraction {
+      predicate typeVariable(TypeParameter tp);
+
+      /** Gets a textual representation of this type abstraction. */
+      string toString();
+
+      /** Gets the location of this type mention. */
+      Location getLocation();
+    }
+
+    class TypeApplication {
+      TypeAbstraction getTarget();
+
+      Type getType(TypeParameter tp, TypePath path);
+
+      /** Gets a textual representation of this type application. */
+      string toString();
+
+      /** Gets the location of this type application. */
+      Location getLocation();
+    }
+
+    class TypeUnderAbstraction {
+      TypeAbstraction getAbstraction();
+
+      Type getType(TypePath path);
+
+      /** Gets a textual representation of this type under abstraction. */
+      string toString();
+
+      /** Gets the location of this type mention. */
+      Location getLocation();
+    }
+  }
+
+  module Substitution2<SubstitutionSig2 Input> {
+    private import Input
+
+    Type substitution(
+      TypeAbstraction abs, TypeApplication app, TypeUnderAbstraction subj, TypePath path
+    ) {
+      app.getTarget() = abs and
+      subj.getAbstraction() = abs and
+      (
+        result = subj.getType(path) and not abs.typeVariable(result)
+        or
+        exists(TypePath prefix, TypePath suffix, TypeParameter tp |
+          path = prefix.append(suffix) and
+          tp = subj.getType(prefix) and
+          abs.typeVariable(tp) and
+          result = app.getType(tp, suffix)
+        )
+      )
+    }
+  }
+
+
+  signature module SubstitutionSig {
+    predicate substitution(TypeParameter tp, TypePath path, Type t);
+
+    Type subject(TypePath path);
+
+    default predicate freeVariable(TypeParameter tp) { substitution(tp, _, _) }
+  }
+
+  module Substitution<SubstitutionSig Input> {
+    private import Input
+
+    Type substituted(TypePath path) {
+      result = subject(path) and not freeVariable(result)
+      or
+      exists(TypePath prefix, TypePath suffix, TypeParameter tp |
+        path = prefix.append(suffix) and
+        tp = subject(prefix) and
+        freeVariable(tp) and
+        substitution(tp, suffix, result)
+      )
+    }
+  }
+
+  ## Signature with type abstraction
+
+  ```java
+  signature module SubstitutionSig {
+    class TypeAbstraction;
+
+    class TypeApplication;
+
+    class TypeTerm;
+
+    predicate typeVariable(TypeAbstraction abs, TypeParameter tp);
+
+    TypeAbstraction applicationGetTarget(TypeApplication app);
+
+    Type applicationGetType(TypeApplication app, TypeParameter tp, TypePath path);
+
+    TypeAbstraction termGetAbstraction(TypeTerm subj);
+
+    Type termGetType(TypeTerm subj, TypePath path);
+  }
+
+  module Substitution<SubstitutionSig Input> {
+    private import Input
+
+    Type substitution(TypeAbstraction abs, TypeApplication app, TypeTerm subj, TypePath path) {
+      abs = applicationGetTarget(app) and
+      abs = termGetAbstraction(subj) and
+      (
+        result = termGetType(subj, path) and not typeVariable(abs, result)
+        or
+        exists(TypePath prefix, TypePath suffix, TypeParameter tp |
+          path = prefix.append(suffix) and
+          tp = termGetType(subj, prefix) and
+          typeVariable(abs, tp) and
+          result = applicationGetType(app, tp, suffix)
+        )
+      )
+    }
+  }
+
+    signature module SatisfiesConstraintSig<HasTypeTreeSig Term> {
+      predicate desiredConstraint(Term term, Constraint Type);
+    }
+
+    module SatisfiesConstraint<HasTypeTreeSig Term, SatisfiesConstraintSig<Term> Input> {
+      predicate termSatisfiesConstraintTypeAt(
+        Term term, TypePath prefix, Type constraint, TypePath path, Type t
+      ) {
+      }
+    }
+
+```