cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/java.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Java language provider.
+ *
+ * Java uses named imports, JVM wildcard/member import resolution,
+ * and a 'public' modifier-based export checker. Heritage uses
+ * EXTENDS by default with implements-split MRO for multiple
+ * interface implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const jvm_js_1 = require("../class-extractors/configs/jvm.js");
+const language_provider_js_1 = require("../language-provider.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const jvm_js_2 = require("../type-extractors/jvm.js");
+const spring_js_1 = require("../route-extractors/spring.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const jvm_js_3 = require("../import-resolvers/configs/jvm.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const generic_js_2 = require("../call-extractors/generic.js");
+const jvm_js_4 = require("../call-extractors/configs/jvm.js");
+const generic_js_3 = require("../field-extractors/generic.js");
+const jvm_js_5 = require("../field-extractors/configs/jvm.js");
+const generic_js_4 = require("../method-extractors/generic.js");
+const jvm_js_6 = require("../method-extractors/configs/jvm.js");
+const generic_js_5 = require("../variable-extractors/generic.js");
+const jvm_js_7 = require("../variable-extractors/configs/jvm.js");
+const java_js_1 = require("../cfg/visitors/java.js");
+const clone_safety_js_1 = require("../workers/clone-safety.js");
+const capture_side_channel_js_1 = require("./java/capture-side-channel.js");
+const index_js_2 = require("./java/index.js");
+/**
+ * Java names the platform owns, matched against a BARE IDENTIFIER — a dropped
+ * receiver's chain base (`System` in `System.out.println(...)`) or the bare
+ * spelling of that base's declared type (`String raw` ⇒ `raw.trim()`). This set
+ * is the ONLY positive evidence `classifyReceiverOrigin` has that a lost edge
+ * pointed OUTSIDE the analyzed program; without it every Java drop hedges
+ * `impact()` down to `epistemic: 'lower-bound'` (#2744).
+ *
+ * TYPE names only — deliberately no method names, unlike `csharp.ts`. The same
+ * hook also gates `type-env.ts`'s return-type inference and the #2545 free-call
+ * shadow guard, both keyed on the CALLEE name; Java method names are camelCase
+ * and collide constantly with user code (`format`, `add`, `get`, `run`, `apply`),
+ * so listing them would silently suppress real in-program resolutions. Receiver
+ * bases are what this pass actually asks about, and those are types.
+ *
+ * Inclusion rule, applied to every entry below: a name earns a place only when
+ * (a) it plausibly appears as a receiver base or bare declared type, and (b) an
+ * application defining its OWN type by that name is implausible. Rule (b) is the
+ * hard gate. A name listed here can never be reported as in-program from the
+ * fallthrough arm, so a wrong entry silently erases a real uncertainty signal,
+ * whereas a missing one only costs a hedge — the failure is asymmetric, so this
+ * set under-includes on purpose.
+ *
+ * Deliberately ABSENT, each for rule (b) — all are ordinary domain nouns an
+ * application really does declare, and `Map`/`Set`/`Collection` are the worst
+ * case because a same-package Java type needs no import to shadow them:
+ *   `Map`, `Set`, `Collection`, `Stream`, `Number`, `Record`, `Error`.
+ * (`Record` and `Error` also fail rule (a): `java.lang.Record` has no callable
+ * static surface and application code never receives a bare `Error`.) `Void`
+ * is absent on rule (a) alone — no `Void` instance exists to be a receiver.
+ * `List` IS included: unlike `Map`, a hand-rolled `List` would fight the
+ * near-universal `java.util.List` import, and it is the highest-value declared
+ * receiver type in the language.
+ */
+const BUILT_INS = new Set([
+    // java.lang — implicitly imported, so these appear unqualified everywhere.
+    'System',
+    'String',
+    'Integer',
+    'Long',
+    'Double',
+    'Boolean',
+    'Character',
+    'Byte',
+    'Short',
+    'Float',
+    'Object',
+    'Math',
+    'Thread',
+    'Runtime',
+    'Class',
+    'StringBuilder',
+    'StringBuffer',
+    'Exception',
+    'RuntimeException',
+    'Throwable',
+    'Iterable',
+    'Comparable',
+    'Runnable',
+    'Enum',
+    // java.util — an explicit import, but an unresolvable one: the import target
+    // is outside the workspace, so it produces no in-program binding and the base
+    // still reaches this set (verified against real scope extraction, not assumed).
+    'Optional',
+    'List',
+    'Arrays',
+    'Collections',
+    'Objects',
+]);
+const orderJavaSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
+    if (!callSiteFilePath.endsWith('.java'))
+        return null;
+    if (candidates.length <= 1)
+        return null;
+    const callerDir = splitDirectorySegments(callSiteFilePath);
+    const scored = candidates.map((candidate, index) => ({
+        candidate,
+        index,
+        score: sharedPrefixLength(callerDir, splitDirectorySegments(candidate.filePath)),
+    }));
+    const bestScore = Math.max(...scored.map((entry) => entry.score));
+    // When all candidates tie, we have no structural signal to prefer one path.
+    // Returning null keeps downstream ambiguity handling conservative.
+    if (scored.every((entry) => entry.score === bestScore))
+        return null;
+    const ordered = [...scored]
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((entry) => entry.candidate);
+    return ordered;
+};
+const splitDirectorySegments = (filePath) => {
+    const normalized = filePath.replace(/\\/g, '/');
+    // Remove empty segments from leading/trailing/multiple slashes, then drop filename.
+    const segments = normalized.split('/').filter(Boolean);
+    return segments.slice(0, -1);
+};
+const sharedPrefixLength = (left, right) => {
+    const max = Math.min(left.length, right.length);
+    let idx = 0;
+    while (idx < max && left[idx] === right[idx])
+        idx += 1;
+    return idx;
+};
+exports.javaProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Java,
+    extensions: ['.java'],
+    entryPointPatterns: [/^do[A-Z]/, /^create[A-Z]/, /^build[A-Z]/, /Service$/],
+    astFrameworkPatterns: [
+        {
+            framework: 'spring',
+            entryPointMultiplier: 3.2,
+            reason: 'spring-annotation',
+            patterns: [
+                '@RestController',
+                '@Controller',
+                '@GetMapping',
+                '@PostMapping',
+                '@RequestMapping',
+            ],
+        },
+        {
+            framework: 'jaxrs',
+            entryPointMultiplier: 3.0,
+            reason: 'jaxrs-annotation',
+            patterns: ['@Path', '@GET', '@POST', '@PUT', '@DELETE'],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.JAVA_QUERIES,
+    typeConfig: jvm_js_2.javaTypeConfig,
+    exportChecker: export_detection_js_1.javaExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(jvm_js_3.javaImportConfig),
+    mroStrategy: 'implements-split',
+    callExtractor: (0, generic_js_2.createCallExtractor)(jvm_js_4.javaCallConfig),
+    fieldExtractor: (0, generic_js_3.createFieldExtractor)(jvm_js_5.javaConfig),
+    methodExtractor: (0, generic_js_4.createMethodExtractor)(jvm_js_6.javaMethodConfig),
+    variableExtractor: (0, generic_js_5.createVariableExtractor)(jvm_js_7.javaVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(jvm_js_1.javaClassConfig),
+    // ── Javadoc → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──
+    emitScopeCaptures: index_js_2.emitJavaScopeCaptures,
+    collectCaptureSideChannel: (filePath) => (0, clone_safety_js_1.assertCloneable)((0, capture_side_channel_js_1.collectJavaCaptureSideChannel)(filePath)),
+    // ── PDG: per-function CFG + def/use harvest (#2195 U4) ──
+    cfgVisitor: (0, java_js_1.createJavaCfgVisitor)(),
+    interpretImport: index_js_2.interpretJavaImport,
+    interpretTypeBinding: index_js_2.interpretJavaTypeBinding,
+    bindingScopeFor: index_js_2.javaBindingScopeFor,
+    importOwningScope: index_js_2.javaImportOwningScope,
+    mergeBindings: (_scope, bindings) => (0, index_js_2.javaMergeBindings)(bindings),
+    receiverBinding: index_js_2.javaReceiverBinding,
+    arityCompatibility: index_js_2.javaArityCompatibility,
+    resolveImportTarget: index_js_2.resolveJavaImportTarget,
+    orderSameNameTypeCandidates: orderJavaSameNameTypeCandidates,
+    // ── Route extraction ──
+    extractDecoratorRoutes: spring_js_1.extractSpringRoutes,
+    extractRouteInheritanceTypes: spring_js_1.extractSpringTypes,
+});

package/dist/core/code/engine/core/ingestion/languages/javascript/arity.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Arity compatibility for JavaScript.
+ *
+ * Delegates to `typescriptArityCompatibility` unchanged — JavaScript
+ * supports the same arity constructs (rest parameters `...args`, default
+ * parameters `p = v`) and the metadata shape (`parameterCount`,
+ * `requiredParameterCount`, `parameterTypes`) is synthesized by the same
+ * `computeTsArityMetadata` function (which understands both TS and JS
+ * parameter node types via `extractTsJsParameters`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsArityCompatibility = void 0;
+var arity_js_1 = require("../typescript/arity.js");
+Object.defineProperty(exports, "jsArityCompatibility", { enumerable: true, get: function () { return arity_js_1.typescriptArityCompatibility; } });