@polymorphism-tech/morph-spec 8.37.1 → 8.40.0

package/src/lib/graph/sanitize.js

@@ -41,13 +41,25 @@ const LANG_BY_EXT = {
 };
 
 /**
- * Projeto de teste em qualquer nível. Três formas, e só três, porque
- * `[^/]*[Tt]ests?/` genérico também casaria `latest/` e `contests/`:
+ * Código de teste — o predicado ÚNICO de "isto é teste" do grafo e do
+ * validador de reuso. Pasta de projeto de teste em qualquer nível, em três
+ * formas, e só três, porque `[^/]*[Tt]ests?/` genérico também casaria
+ * `latest/` e `contests/`:
  *   - o segmento inteiro é `test`/`tests` (qualquer caixa)
  *   - termina em `.Test`/`.Tests` — a convenção .NET (ProspectPRO.Tests/)
  *   - termina em `Test`/`Tests` com T maiúsculo — PascalCase (AlvoTests/)
+ * mais o teste colocado ao lado do código em JS/TS: `__tests__/`,
+ * `*.test.*` e `*.spec.*`.
  */
-const TEST_PATH = /(^|\/)(?:[Tt]ests?|[^/]*\.[Tt]ests?|[^/]*[a-z0-9_]Tests?)\//;
+const TEST_PATH = /(^|\/)__tests__\/|\.(test|spec)\.[jt]sx?$|(^|\/)(?:[Tt]ests?|[^/]*\.[Tt]ests?|[^/]*[a-z0-9_]Tests?)\//;
+
+/**
+ * @param {string} sourceFile
+ * @returns {boolean} o arquivo é código de teste (dublê, fixture ou o teste em si)
+ */
+export function isTestPath(sourceFile) {
+  return TEST_PATH.test(String(sourceFile || '').replace(/\\/g, '/'));
+}
 
 /**
  * @param {string} sourceFile
@@ -75,6 +87,7 @@ const baseOf = (norm) => norm.replace(/\(\s*\)$/, '');
  * @property {Map<string, {real: object[], stub: object[]}>} byLabel
  * @property {Map<string, object[]>} byBaseLabel label sem `()` -> nós reais
  * @property {Map<string, string>} coalesce stubId -> id do nó real
+ * @property {object[]} recovered `dispatches_to` recuperados (ver recoverDispatch)
  */
 
 /**
@@ -114,7 +127,94 @@ export function buildIndex(graph) {
     else byBaseLabel.set(base, [...entry.real]);
   }
 
-  return { byId, byLabel, byBaseLabel, coalesce };
+  const index = { byId, byLabel, byBaseLabel, coalesce, recovered: [] };
+  index.recovered = recoverDispatch(index, graph);
+  return index;
+}
+
+const isCsharp = (node) => Boolean(node?.source_file) && /\.cs$/i.test(node.source_file);
+
+/** Nome do método sem o ponto inicial e sem a assinatura, como o graphify casa. */
+const methodName = (node) => String(node.label ?? '').trim().replace(/^\./, '').split('(')[0];
+
+/**
+ * `dispatches_to` que o graphify deixou de emitir por causa de um dublê de
+ * teste. O resolvedor dele (graphify/csharp_dispatch.py) liga o método da
+ * interface ao da implementação só quando há EXATAMENTE um implementador — e
+ * um `FakeX : IX` no grafo é o segundo. Este é o mesmo algoritmo, com o guard
+ * contando só implementadores de produção. Medido no MORPH_GHLBrain: com os
+ * dublês no grafo o graphify cai de 122 para 5 arestas, e esta função devolve
+ * as 122 do grafo sem testes, nenhuma a mais.
+ *
+ * Aditivo: um par que o graphify já emitiu não é repetido.
+ *
+ * @param {GraphIndex} index
+ * @param {{links?: object[]}} graph
+ * @returns {object[]} arestas sintéticas, marcadas `_recovered: true`
+ */
+function recoverDispatch(index, graph) {
+  const implementers = new Map();
+  const methodsOf = new Map();
+  const existing = new Set();
+
+  for (const link of graph.links ?? []) {
+    if (link.relation === 'dispatches_to') {
+      existing.add(`${link.source}|${link.target}`);
+    } else if (link.relation === 'implements') {
+      const impl = index.byId.get(link.source);
+      if (!impl || isTestPath(impl.source_file)) continue;
+      const iface = resolveEdgeTarget(index, link).id;
+      if (!iface) continue;
+      if (!implementers.has(iface)) implementers.set(iface, new Set());
+      implementers.get(iface).add(link.source);
+    } else if (link.relation === 'method') {
+      const method = index.byId.get(link.target);
+      if (!isCsharp(method)) continue;
+      const name = methodName(method);
+      if (!name) continue;
+      if (!methodsOf.has(link.source)) methodsOf.set(link.source, new Map());
+      const byName = methodsOf.get(link.source);
+      if (!byName.has(name)) byName.set(name, new Set());
+      byName.get(name).add(link.target);
+    }
+  }
+
+  const recovered = [];
+  for (const [ifaceId, impls] of implementers) {
+    if (impls.size !== 1) continue;
+    const [implId] = impls;
+    const impl = index.byId.get(implId);
+    if (!isCsharp(index.byId.get(ifaceId)) || !isCsharp(impl)) continue;
+    const implMethods = methodsOf.get(implId) ?? new Map();
+    for (const [name, declared] of methodsOf.get(ifaceId) ?? new Map()) {
+      const candidates = implMethods.get(name);
+      if (declared.size !== 1 || candidates?.size !== 1) continue;
+      const [source] = declared;
+      const [target] = candidates;
+      const key = `${source}|${target}`;
+      if (source === target || existing.has(key)) continue;
+      existing.add(key);
+      recovered.push({
+        source, target, relation: 'dispatches_to', context: 'call',
+        source_file: impl.source_file, source_location: impl.source_location ?? '',
+        _recovered: true,
+      });
+    }
+  }
+  return recovered;
+}
+
+/**
+ * As arestas do grafo mais as recuperadas pelo saneamento — o conjunto que
+ * todo consumidor deve percorrer.
+ *
+ * @param {GraphIndex} index
+ * @param {{links?: object[]}} graph
+ * @returns {object[]}
+ */
+export function linksOf(index, graph) {
+  const own = graph.links ?? [];
+  return index.recovered?.length ? own.concat(index.recovered) : own;
 }
 
 /**
@@ -201,20 +301,21 @@ export function resolveLabel(index, label) {
  * @param {{links: object[]}} graph
  * @param {string} id
  * @param {{prod?: boolean, excludeInheritance?: boolean}} [opts]
- * @returns {Array<{id: string, label: string, source_file: string, source_location: string, relation: string}>}
+ * @returns {Array<{id: string, label: string, source_file: string, source_location: string, relation: string, test: boolean}>}
  */
 export function affected(index, graph, id, opts = {}) {
   const seen = new Set();
   const out = [];
 
-  for (const link of graph.links ?? []) {
+  for (const link of linksOf(index, graph)) {
     if (!USE_RELATIONS.has(link.relation)) continue;
     if (opts.excludeInheritance && INHERITANCE_RELATIONS.has(link.relation)) continue;
     if (resolveEdgeTarget(index, link).id !== id) continue;
 
     const source = index.byId.get(link.source);
     if (!source || !source.source_file) continue;
-    if (opts.prod && TEST_PATH.test(source.source_file)) continue;
+    const test = isTestPath(source.source_file);
+    if (opts.prod && test) continue;
 
     const key = `${source.id}|${link.relation}`;
     if (seen.has(key)) continue;
@@ -226,6 +327,7 @@ export function affected(index, graph, id, opts = {}) {
       source_file: source.source_file,
       source_location: source.source_location ?? '',
       relation: link.relation,
+      test,
     });
   }
 
@@ -234,7 +336,8 @@ export function affected(index, graph, id, opts = {}) {
 
 /**
  * Vizinhança de um nó, para `graph explain`. Cada aresta carrega a procedência
- * (`via`), então dá para ver o que o saneamento recuperou.
+ * (`via`), então dá para ver o que o saneamento recuperou, e `test` diz se a
+ * outra ponta é código de teste.
  *
  * @param {GraphIndex} index
  * @param {{links: object[]}} graph
@@ -244,8 +347,9 @@ export function neighborhood(index, graph, id) {
   const incoming = [];
   const outgoing = [];
 
-  for (const link of graph.links ?? []) {
+  for (const link of linksOf(index, graph)) {
     const resolved = resolveEdgeTarget(index, link);
+    const via = link._recovered ? 'recovered-dispatch' : resolved.kind;
 
     if (resolved.id === id) {
       const source = index.byId.get(link.source);
@@ -256,7 +360,8 @@ export function neighborhood(index, graph, id) {
           relation: link.relation,
           source_file: link.source_file || source.source_file,
           source_location: link.source_location || source.source_location || '',
-          via: resolved.kind,
+          via,
+          test: isTestPath(source.source_file),
         });
       }
     }
@@ -270,7 +375,8 @@ export function neighborhood(index, graph, id) {
           relation: link.relation,
           source_file: link.source_file || target.source_file,
           source_location: link.source_location || '',
-          via: resolved.kind,
+          via,
+          test: isTestPath(target.source_file),
         });
       }
     }