circle-ir 4.9.29 → 4.11.0

package/dist/core/circle-ir-core.cjs

@@ -4458,7 +4458,7 @@ function detectLanguage(tree) {
   if (pythonScore > jsScore && pythonScore > javaScore) return "python";
   return jsScore > javaScore ? "javascript" : "java";
 }
-function extractTypes(tree, cache, language) {
+function extractTypes(tree, cache, language, options) {
   const effectiveLanguage = language ?? detectLanguage(tree);
   const isJavaScript = effectiveLanguage === "javascript" || effectiveLanguage === "typescript" || effectiveLanguage === "tsx";
   const isPython = effectiveLanguage === "python";
@@ -4478,7 +4478,7 @@ function extractTypes(tree, cache, language) {
   if (effectiveLanguage === "csharp") {
     return extractCSharpTypes(tree, cache);
   }
-  return extractJavaTypes(tree, cache);
+  return extractJavaTypes(tree, cache, options);
 }
 function csharpMemberNodes(body2) {
   if (!body2) return [];
@@ -4619,7 +4619,7 @@ function extractCSharpModifiers(node) {
   }
   return mods;
 }
-function extractJavaTypes(tree, cache) {
+function extractJavaTypes(tree, cache, options) {
   const types = [];
   const classes = getNodesFromCache(tree.rootNode, "class_declaration", cache);
   for (const cls of classes) {
@@ -4633,8 +4633,76 @@ function extractJavaTypes(tree, cache) {
   for (const enumDecl of enums) {
     types.push(extractEnumInfo(enumDecl));
   }
+  if (!options?.navigationTypes) return types;
+  for (const rec of getNodesFromCache(tree.rootNode, "record_declaration", cache)) {
+    const info2 = extractClassInfo(rec);
+    info2.is_record = true;
+    for (const comp of recordComponents(rec)) {
+      if (!info2.fields.some((f) => f.name === comp.name)) {
+        info2.fields.push({
+          name: comp.name,
+          type: comp.type,
+          modifiers: ["private", "final"],
+          annotations: []
+        });
+      }
+      if (!info2.methods.some((m) => m.name === comp.name)) {
+        info2.methods.push({
+          name: comp.name,
+          return_type: comp.type,
+          parameters: [],
+          annotations: [],
+          modifiers: ["public"],
+          start_line: rec.startPosition.row + 1,
+          end_line: rec.startPosition.row + 1
+        });
+      }
+    }
+    types.push(info2);
+  }
+  const declNodes = [
+    ...classes,
+    ...interfaces,
+    ...enums,
+    ...getNodesFromCache(tree.rootNode, "record_declaration", cache)
+  ];
+  for (const t of types) {
+    const node = declNodes.find(
+      (n) => n.startPosition.row + 1 === t.start_line && getIdentifier(n, "name") === t.name
+    );
+    const path = node ? enclosingTypePath(node) : [];
+    if (path.length > 0) t.enclosing_type = path.join(".");
+  }
   return types;
 }
+function recordComponents(node) {
+  const out2 = [];
+  const params = node.childForFieldName("parameters");
+  if (!params) return out2;
+  for (let i2 = 0; i2 < params.childCount; i2++) {
+    const c = params.child(i2);
+    if (!c || c.type !== "formal_parameter") continue;
+    const name2 = c.childForFieldName("name");
+    const type = c.childForFieldName("type");
+    if (name2) out2.push({ name: getNodeText(name2), type: type ? getNodeText(type) : null });
+  }
+  return out2;
+}
+function enclosingTypePath(node) {
+  const DECLS = /* @__PURE__ */ new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration"
+  ]);
+  const path = [];
+  for (let p = node.parent; p; p = p.parent) {
+    if (!DECLS.has(p.type)) continue;
+    const n = getIdentifier(p, "name");
+    if (n) path.unshift(n);
+  }
+  return path;
+}
 function extractJavaScriptTypes(tree, cache) {
   const types = [];
   const classes = getNodesFromCache(tree.rootNode, "class_declaration", cache);
@@ -13417,6 +13485,29 @@ var DEFAULT_SINKS = [
   { method: "deserialize", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
   { method: "from_str", class: "toml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
   { method: "from_str", class: "ron", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  // cognium-dev#541 — the crates the removed classless rows were silently
+  // covering. #484 replaced a classless `from_str` / `from_slice` with
+  // class-scoped rows, but only for the four formats that already had entries;
+  // every other serde data format lost its sink, and `rmp_serde::from_slice`
+  // on bytes read straight off a `TcpStream` stopped being reported. Each row
+  // below is a serde *data format* entry point — a function whose whole job is
+  // to build a typed value out of untrusted bytes or text.
+  { method: "from_slice", class: "rmp_serde", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_read", class: "rmp_serde", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_read_ref", class: "rmp_serde", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "serde_yaml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "toml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "ron", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_bytes", class: "postcard", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "serde_cbor", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "serde_cbor", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "ciborium", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_str", class: "serde_xml_rs", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "serde_xml_rs", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_str", class: "quick_xml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "quick_xml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
+  { method: "deserialize_from", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
   // #294/#484: no classless `from_str` / `from_slice` deserialization sink.
   // Those rows matched EVERY `T::from_str` / `from_slice` — `u32::from_str`,
   // `Url::from_str`, `PublicKey::from_slice` — i.e. ordinary `FromStr` / byte

package/dist/core/circle-ir-core.js

@@ -4392,7 +4392,7 @@ function detectLanguage(tree) {
   if (pythonScore > jsScore && pythonScore > javaScore) return "python";
   return jsScore > javaScore ? "javascript" : "java";
 }
-function extractTypes(tree, cache, language) {
+function extractTypes(tree, cache, language, options) {
   const effectiveLanguage = language ?? detectLanguage(tree);
   const isJavaScript = effectiveLanguage === "javascript" || effectiveLanguage === "typescript" || effectiveLanguage === "tsx";
   const isPython = effectiveLanguage === "python";
@@ -4412,7 +4412,7 @@ function extractTypes(tree, cache, language) {
   if (effectiveLanguage === "csharp") {
     return extractCSharpTypes(tree, cache);
   }
-  return extractJavaTypes(tree, cache);
+  return extractJavaTypes(tree, cache, options);
 }
 function csharpMemberNodes(body2) {
   if (!body2) return [];
@@ -4553,7 +4553,7 @@ function extractCSharpModifiers(node) {
   }
   return mods;
 }
-function extractJavaTypes(tree, cache) {
+function extractJavaTypes(tree, cache, options) {
   const types = [];
   const classes = getNodesFromCache(tree.rootNode, "class_declaration", cache);
   for (const cls of classes) {
@@ -4567,8 +4567,76 @@ function extractJavaTypes(tree, cache) {
   for (const enumDecl of enums) {
     types.push(extractEnumInfo(enumDecl));
   }
+  if (!options?.navigationTypes) return types;
+  for (const rec of getNodesFromCache(tree.rootNode, "record_declaration", cache)) {
+    const info2 = extractClassInfo(rec);
+    info2.is_record = true;
+    for (const comp of recordComponents(rec)) {
+      if (!info2.fields.some((f) => f.name === comp.name)) {
+        info2.fields.push({
+          name: comp.name,
+          type: comp.type,
+          modifiers: ["private", "final"],
+          annotations: []
+        });
+      }
+      if (!info2.methods.some((m) => m.name === comp.name)) {
+        info2.methods.push({
+          name: comp.name,
+          return_type: comp.type,
+          parameters: [],
+          annotations: [],
+          modifiers: ["public"],
+          start_line: rec.startPosition.row + 1,
+          end_line: rec.startPosition.row + 1
+        });
+      }
+    }
+    types.push(info2);
+  }
+  const declNodes = [
+    ...classes,
+    ...interfaces,
+    ...enums,
+    ...getNodesFromCache(tree.rootNode, "record_declaration", cache)
+  ];
+  for (const t of types) {
+    const node = declNodes.find(
+      (n) => n.startPosition.row + 1 === t.start_line && getIdentifier(n, "name") === t.name
+    );
+    const path = node ? enclosingTypePath(node) : [];
+    if (path.length > 0) t.enclosing_type = path.join(".");
+  }
   return types;
 }
+function recordComponents(node) {
+  const out2 = [];
+  const params = node.childForFieldName("parameters");
+  if (!params) return out2;
+  for (let i2 = 0; i2 < params.childCount; i2++) {
+    const c = params.child(i2);
+    if (!c || c.type !== "formal_parameter") continue;
+    const name2 = c.childForFieldName("name");
+    const type = c.childForFieldName("type");
+    if (name2) out2.push({ name: getNodeText(name2), type: type ? getNodeText(type) : null });
+  }
+  return out2;
+}
+function enclosingTypePath(node) {
+  const DECLS = /* @__PURE__ */ new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration"
+  ]);
+  const path = [];
+  for (let p = node.parent; p; p = p.parent) {
+    if (!DECLS.has(p.type)) continue;
+    const n = getIdentifier(p, "name");
+    if (n) path.unshift(n);
+  }
+  return path;
+}
 function extractJavaScriptTypes(tree, cache) {
   const types = [];
   const classes = getNodesFromCache(tree.rootNode, "class_declaration", cache);
@@ -13351,6 +13419,29 @@ var DEFAULT_SINKS = [
   { method: "deserialize", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
   { method: "from_str", class: "toml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
   { method: "from_str", class: "ron", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  // cognium-dev#541 — the crates the removed classless rows were silently
+  // covering. #484 replaced a classless `from_str` / `from_slice` with
+  // class-scoped rows, but only for the four formats that already had entries;
+  // every other serde data format lost its sink, and `rmp_serde::from_slice`
+  // on bytes read straight off a `TcpStream` stopped being reported. Each row
+  // below is a serde *data format* entry point — a function whose whole job is
+  // to build a typed value out of untrusted bytes or text.
+  { method: "from_slice", class: "rmp_serde", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_read", class: "rmp_serde", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_read_ref", class: "rmp_serde", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "serde_yaml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "toml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "ron", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_bytes", class: "postcard", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "serde_cbor", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "serde_cbor", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "ciborium", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_str", class: "serde_xml_rs", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "serde_xml_rs", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_str", class: "quick_xml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_reader", class: "quick_xml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
+  { method: "from_slice", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
+  { method: "deserialize_from", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
   // #294/#484: no classless `from_str` / `from_slice` deserialization sink.
   // Those rows matched EVERY `T::from_str` / `from_slice` — `u32::from_str`,
   // `Url::from_str`, `PublicKey::from_slice` — i.e. ordinary `FromStr` / byte

package/dist/core/extractors/types.d.ts

@@ -4,8 +4,35 @@
 import type { Tree } from 'web-tree-sitter';
 import type { TypeInfo, SupportedLanguage } from '../../types/index.js';
 import { type NodeCache } from '../parser.js';
+/**
+ * Extra type information the navigation API needs and no existing consumer
+ * expects. Every field it adds is optional and absent unless asked for, so
+ * `extractTypes(tree, cache, language)` returns exactly what it always did.
+ *
+ * Two things are missing from the default Java extraction, both found by
+ * auditing the call sites the resolver cannot bind:
+ *
+ *   - **A `record` yields no type at all.** `extractJavaTypes` walks
+ *     `class_declaration`, `interface_declaration` and `enum_declaration`;
+ *     `record_declaration` is not among them, so a record is invisible — not
+ *     in `ir.types`, and its body's calls are not in `ir.calls` either.
+ *     Records are ordinary Java 17+ code and cost 182 of 455 bindable misses
+ *     in the 405-file sample, the single largest cause.
+ *   - **Nesting is lost.** `Outer.Inner` is emitted as a type named `Inner`,
+ *     so its fully-qualified name collides with a top-level `Inner` and an
+ *     `import static app.Outer.Inner.make` cannot be matched to it.
+ *
+ * Both are fixed here rather than in the default path because `ir.types` is
+ * read by the SAST passes and by the method-scoping gate: adding a type, or
+ * changing one's identity, changes their results and belongs behind the SAST
+ * corpora gates, not in a navigation change.
+ */
+export interface TypeExtractionOptions {
+    /** Emit `record_declaration` types, and set `enclosing_type` on nested types. */
+    navigationTypes?: boolean;
+}
 /**
  * Extract all type definitions from the tree.
  */
-export declare function extractTypes(tree: Tree, cache?: NodeCache, language?: SupportedLanguage): TypeInfo[];
+export declare function extractTypes(tree: Tree, cache?: NodeCache, language?: SupportedLanguage, options?: TypeExtractionOptions): TypeInfo[];
 //# sourceMappingURL=types.d.ts.map

package/dist/core/extractors/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAwC,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAA6C,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAgDzF;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CAsBpG"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAwC,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAA6C,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAgDzF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,EACV,KAAK,CAAC,EAAE,SAAS,EACjB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,QAAQ,EAAE,CAsBZ"}

package/dist/core/extractors/types.js

@@ -49,7 +49,7 @@ function detectLanguage(tree) {
 /**
  * Extract all type definitions from the tree.
  */
-export function extractTypes(tree, cache, language) {
+export function extractTypes(tree, cache, language, options) {
     const effectiveLanguage = language ?? detectLanguage(tree);
     const isJavaScript = effectiveLanguage === 'javascript' || effectiveLanguage === 'typescript' || effectiveLanguage === 'tsx';
     const isPython = effectiveLanguage === 'python';
@@ -69,7 +69,7 @@ export function extractTypes(tree, cache, language) {
     if (effectiveLanguage === 'csharp') {
         return extractCSharpTypes(tree, cache);
     }
-    return extractJavaTypes(tree, cache);
+    return extractJavaTypes(tree, cache, options);
 }
 /**
  * C# type extraction (Phase-0 spike — cognium-dev C#/.NET epic).
@@ -278,7 +278,7 @@ function extractCSharpModifiers(node) {
 /**
  * Extract Java types.
  */
-function extractJavaTypes(tree, cache) {
+function extractJavaTypes(tree, cache, options) {
     const types = [];
     // Extract classes
     const classes = getNodesFromCache(tree.rootNode, 'class_declaration', cache);
@@ -295,8 +295,91 @@ function extractJavaTypes(tree, cache) {
     for (const enumDecl of enums) {
         types.push(extractEnumInfo(enumDecl));
     }
+    if (!options?.navigationTypes)
+        return types;
+    // Records, which the default path omits entirely. A record's body holds
+    // ordinary method declarations, so `extractClassInfo` reads it unchanged;
+    // only the node type and the `is_record` marker differ.
+    for (const rec of getNodesFromCache(tree.rootNode, 'record_declaration', cache)) {
+        const info = extractClassInfo(rec);
+        info.is_record = true;
+        // A record's components are its fields and its accessors. Both are
+        // declared by the header, not written in the body, so neither
+        // `extractFields` nor `extractMethods` can see them.
+        for (const comp of recordComponents(rec)) {
+            if (!info.fields.some(f => f.name === comp.name)) {
+                info.fields.push({
+                    name: comp.name,
+                    type: comp.type,
+                    modifiers: ['private', 'final'],
+                    annotations: [],
+                });
+            }
+            if (!info.methods.some(m => m.name === comp.name)) {
+                info.methods.push({
+                    name: comp.name,
+                    return_type: comp.type,
+                    parameters: [],
+                    annotations: [],
+                    modifiers: ['public'],
+                    start_line: rec.startPosition.row + 1,
+                    end_line: rec.startPosition.row + 1,
+                });
+            }
+        }
+        types.push(info);
+    }
+    // Nesting, which the default path flattens. Walking every emitted type's
+    // ancestors is cheaper than threading the path through five extractors.
+    const declNodes = [
+        ...classes,
+        ...interfaces,
+        ...enums,
+        ...getNodesFromCache(tree.rootNode, 'record_declaration', cache),
+    ];
+    for (const t of types) {
+        const node = declNodes.find(n => n.startPosition.row + 1 === t.start_line && getIdentifier(n, 'name') === t.name);
+        const path = node ? enclosingTypePath(node) : [];
+        if (path.length > 0)
+            t.enclosing_type = path.join('.');
+    }
     return types;
 }
+/** The `(String host, int port)` header of a `record_declaration`. */
+function recordComponents(node) {
+    const out = [];
+    const params = node.childForFieldName('parameters');
+    if (!params)
+        return out;
+    for (let i = 0; i < params.childCount; i++) {
+        const c = params.child(i);
+        if (!c || c.type !== 'formal_parameter')
+            continue;
+        const name = c.childForFieldName('name');
+        const type = c.childForFieldName('type');
+        if (name)
+            out.push({ name: getNodeText(name), type: type ? getNodeText(type) : null });
+    }
+    return out;
+}
+/** The names of the types a declaration sits inside, outermost first. */
+function enclosingTypePath(node) {
+    const DECLS = new Set([
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ]);
+    const path = [];
+    for (let p = node.parent; p; p = p.parent) {
+        if (!DECLS.has(p.type))
+            continue;
+        const n = getIdentifier(p, 'name');
+        if (n)
+            path.unshift(n);
+    }
+    return path;
+}
 /**
  * Extract JavaScript/TypeScript types.
  */