wehub-resource-sync
527 lines
22 KiB
C
527 lines
22 KiB
C
/*
|
|
* repro_grammar_core.c -- Exhaustive per-grammar INVARIANT battery for the
|
|
* COMPILED / OOP language family.
|
|
*
|
|
* One TEST() per language so per-language RED/GREEN shows on the bug-repro
|
|
* board. Each test runs the SAME battery against a tiny idiomatic fixture for
|
|
* that language (a function/method that CALLS another function strictly inside
|
|
* its body, a class/struct where the language has one, and an idiomatic
|
|
* import/include). The shared single-file + pipeline runners keep this DRY.
|
|
*
|
|
* Languages covered (12) and the CBM_LANG_* enum each uses:
|
|
* C -> CBM_LANG_C
|
|
* C++ -> CBM_LANG_CPP
|
|
* CUDA -> CBM_LANG_CUDA
|
|
* Rust -> CBM_LANG_RUST
|
|
* Go -> CBM_LANG_GO
|
|
* Java -> CBM_LANG_JAVA
|
|
* C# -> CBM_LANG_CSHARP
|
|
* Kotlin -> CBM_LANG_KOTLIN
|
|
* Scala -> CBM_LANG_SCALA
|
|
* Swift -> CBM_LANG_SWIFT
|
|
* Obj-C -> CBM_LANG_OBJC
|
|
* D -> CBM_LANG_DLANG
|
|
*
|
|
* BATTERY DIMENSIONS
|
|
* ------------------
|
|
* SINGLE-FILE (cbm_extract_file, via inv_rx + inv_count_* helpers):
|
|
* 1. extract-clean : inv_extract_clean(src,lang,file) == 1
|
|
* (parser returned a result and did not set has_error;
|
|
* a hard crash would not return at all).
|
|
* 2. labels-valid : inv_count_bad_labels(r) == 0 (every def label is in
|
|
* the known label set).
|
|
* 3. fqn-wellformed : inv_count_bad_fqns(r) == 0 (no empty/".."/leading
|
|
* or trailing '.'/whitespace QNs).
|
|
* 4. ranges-valid : inv_count_bad_ranges(r) == 0 (start_line >= 1 and
|
|
* start_line <= end_line for every def).
|
|
* 5. defs-present : the function/class written in the fixture is extracted
|
|
* (inv_count_label for the expected def labels > 0).
|
|
* 6. calls-extracted : inv_has_call(r, "<callee>") == 1 (the in-body call was
|
|
* captured).
|
|
*
|
|
* FULL-PIPELINE (rh_index_files -> cbm_store_t*, via inv_count_* store helpers):
|
|
* 7. callable-sourcing : inv_count_calls_by_source(store,project,&mod,&call);
|
|
* assert mod == 0 -- every in-body call must be sourced
|
|
* at a Function/Method node, NEVER at a Module node.
|
|
* 8. no-dangling : inv_count_dangling_edges(store,project,"CALLS") == 0
|
|
* (every CALLS edge resolves both endpoints).
|
|
*
|
|
* KNOWN GAP (the point of this file): dimension 7 (callable-sourcing) is RED for
|
|
* most of the compiled/OOP languages on current code. Per QUALITY_ANALYSIS.md
|
|
* (2026-06-24) only ~3.69% of CALLS edges in the real graph are callable-sourced;
|
|
* the dominant failure is cbm_enclosing_func_qn falling back to the module QN when
|
|
* cbm_find_enclosing_func cannot walk the TSNode ancestry to a function node
|
|
* (func_kinds_for_lang in helpers.c not matching the grammar's emitted node
|
|
* types), and the LSP rescue cannot compensate because it joins on exact caller_qn
|
|
* equality. So dimensions 1-6 and 8 are expected GREEN for these idiomatic
|
|
* fixtures; dimension 7 is expected RED for C/C++/Rust/Java/C#/Kotlin/Scala/
|
|
* Swift/Obj-C/D and GREEN for Go/CUDA (Go is grep-validated correct; CUDA is a
|
|
* listed GREEN in the breadth table). RED dimension-7 rows ARE the deliverable.
|
|
*
|
|
* Coding rule: inline comments are line comments only (no block comments inside
|
|
* block comments).
|
|
*/
|
|
|
|
#include "test_framework.h"
|
|
#include "repro_invariant_lib.h"
|
|
#include <store/store.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
/* ── Shared single-file battery (dimensions 1-6) ────────────────────────────
|
|
*
|
|
* Runs the six single-file invariants against one fixture. Returns 0 when all
|
|
* pass, 1 otherwise (printing a per-dimension FAIL line). lang_tag is for
|
|
* diagnostics only. expect_label / expect_label2 are def labels the fixture is
|
|
* guaranteed to produce (e.g. "Function" and "Class"/"Struct"); pass NULL for
|
|
* expect_label2 when the language has no class/struct in the fixture. callee is
|
|
* the in-body callee name that must appear in the extracted calls.
|
|
*/
|
|
static int single_file_battery(const char *lang_tag, const char *src,
|
|
CBMLanguage lang, const char *file,
|
|
const char *expect_label,
|
|
const char *expect_label2, const char *callee) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
int fails = 0;
|
|
|
|
/* 1. extract-clean -- must hold before anything else is meaningful. */
|
|
if (inv_extract_clean(src, lang, file) != 1) {
|
|
printf(" %sFAIL%s [%s] extract-clean: NULL result or has_error set\n",
|
|
RED, RST, lang_tag);
|
|
return 1; /* nothing else can be trusted */
|
|
}
|
|
|
|
CBMFileResult *r = inv_rx(src, lang, file);
|
|
if (!r) {
|
|
printf(" %sFAIL%s [%s] inv_rx returned NULL after clean extract\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
/* 2. labels-valid */
|
|
int bad_labels = inv_count_bad_labels(r);
|
|
if (bad_labels != 0) {
|
|
printf(" %sFAIL%s [%s] labels-valid: %d def(s) with invalid label\n",
|
|
RED, RST, lang_tag, bad_labels);
|
|
fails++;
|
|
}
|
|
|
|
/* 3. fqn-wellformed */
|
|
int bad_fqns = inv_count_bad_fqns(r);
|
|
if (bad_fqns != 0) {
|
|
printf(" %sFAIL%s [%s] fqn-wellformed: %d def(s) with malformed QN\n",
|
|
RED, RST, lang_tag, bad_fqns);
|
|
fails++;
|
|
}
|
|
|
|
/* 4. ranges-valid */
|
|
int bad_ranges = inv_count_bad_ranges(r);
|
|
if (bad_ranges != 0) {
|
|
printf(" %sFAIL%s [%s] ranges-valid: %d def(s) with invalid range\n",
|
|
RED, RST, lang_tag, bad_ranges);
|
|
fails++;
|
|
}
|
|
|
|
/* 5. defs-present -- the function/class the fixture wrote must be extracted. */
|
|
if (expect_label && inv_count_label(r, expect_label) < 1) {
|
|
printf(" %sFAIL%s [%s] defs-present: no def labelled \"%s\"\n",
|
|
RED, RST, lang_tag, expect_label);
|
|
fails++;
|
|
}
|
|
if (expect_label2 && inv_count_label(r, expect_label2) < 1) {
|
|
printf(" %sFAIL%s [%s] defs-present: no def labelled \"%s\"\n",
|
|
RED, RST, lang_tag, expect_label2);
|
|
fails++;
|
|
}
|
|
|
|
/* 6. calls-extracted -- the in-body call must be captured. */
|
|
if (inv_has_call(r, callee) != 1) {
|
|
printf(" %sFAIL%s [%s] calls-extracted: no call to \"%s\" found\n",
|
|
RED, RST, lang_tag, callee);
|
|
fails++;
|
|
}
|
|
|
|
cbm_free_result(r);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── Shared full-pipeline battery (dimensions 7-8) ──────────────────────────
|
|
*
|
|
* Indexes the single-file fixture through the production pipeline and asserts
|
|
* callable-sourcing (no Module-sourced in-body CALLS) and no dangling CALLS
|
|
* edges. Returns 0 on PASS, 1 on FAIL. Dimension 7 is RED for most compiled/
|
|
* OOP languages on current code -- that is the intended signal.
|
|
*/
|
|
static int pipeline_battery(const char *lang_tag, const char *filename,
|
|
const char *src) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
RFile files[1];
|
|
files[0].name = filename;
|
|
files[0].content = src;
|
|
|
|
RProj lp;
|
|
cbm_store_t *store = rh_index_files(&lp, files, 1);
|
|
if (!store) {
|
|
printf(" %sFAIL%s [%s] pipeline: rh_index_files returned NULL\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
int fails = 0;
|
|
|
|
/* 7. callable-sourcing -- mod must be 0; we also require >=1 callable-sourced
|
|
* edge so a fixture that produced zero CALLS edges cannot vacuously pass. */
|
|
int module_sourced = 0;
|
|
int callable_sourced = 0;
|
|
inv_count_calls_by_source(store, lp.project, &module_sourced,
|
|
&callable_sourced);
|
|
if (module_sourced != 0) {
|
|
printf(" %sFAIL%s [%s] callable-sourcing: %d in-body CALLS sourced at "
|
|
"Module (callable=%d) -- known enclosing-func gap\n",
|
|
RED, RST, lang_tag, module_sourced, callable_sourced);
|
|
fails++;
|
|
} else if (callable_sourced < 1) {
|
|
printf(" %sFAIL%s [%s] callable-sourcing: 0 CALLS edges (fixture "
|
|
"produced no in-body call edge to attribute)\n",
|
|
RED, RST, lang_tag);
|
|
fails++;
|
|
}
|
|
|
|
/* 8. no-dangling -- every CALLS edge endpoint must resolve. */
|
|
int dangling = inv_count_dangling_edges(store, lp.project, "CALLS");
|
|
if (dangling != 0) {
|
|
printf(" %sFAIL%s [%s] no-dangling: %d dangling CALLS endpoint(s)\n",
|
|
RED, RST, lang_tag, dangling);
|
|
fails++;
|
|
}
|
|
|
|
rh_cleanup(&lp, store);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── C ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: #include header, two free functions, callee inside the body.
|
|
* C has no class/struct def in this fixture (struct shown but the def set we
|
|
* assert on is the Function). Expected: dims 1-6 + 8 GREEN, dim 7 RED
|
|
* (func_kinds_cpp shared with C; C dominates the Module-sourced CALLS list).
|
|
*/
|
|
TEST(repro_grammar_core_c) {
|
|
static const char src[] =
|
|
"#include <stdio.h>\n"
|
|
"\n"
|
|
"static int add(int a, int b) {\n"
|
|
" return a + b;\n"
|
|
"}\n"
|
|
"\n"
|
|
"int compute(int x) {\n"
|
|
" return add(x, 1);\n"
|
|
"}\n";
|
|
if (single_file_battery("C", src, CBM_LANG_C, "main.c",
|
|
"Function", NULL, "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("C", "main.c", src);
|
|
}
|
|
|
|
/* ── C++ ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: #include, a class with a method, a free helper, in-body call.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 RED (shares func_kinds with C; out-of-
|
|
* line method defs also drop the class qualifier, issue #554).
|
|
*/
|
|
TEST(repro_grammar_core_cpp) {
|
|
static const char src[] =
|
|
"#include <vector>\n"
|
|
"\n"
|
|
"static int helper(int x) {\n"
|
|
" return x * 2;\n"
|
|
"}\n"
|
|
"\n"
|
|
"class Processor {\n"
|
|
"public:\n"
|
|
" int run(int v) {\n"
|
|
" return helper(v);\n"
|
|
" }\n"
|
|
"};\n";
|
|
if (single_file_battery("C++", src, CBM_LANG_CPP, "main.cpp",
|
|
"Method", "Class", "helper") != 0)
|
|
return 1;
|
|
return pipeline_battery("C++", "main.cpp", src);
|
|
}
|
|
|
|
/* ── CUDA ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: a __device__ helper called from a __global__ kernel body.
|
|
* Expected GREEN across the battery including dim 7 (CUDA is a listed GREEN in
|
|
* the breadth callable-sourcing table).
|
|
*/
|
|
TEST(repro_grammar_core_cuda) {
|
|
static const char src[] =
|
|
"__device__ int helper(int x) {\n"
|
|
" return x * 2;\n"
|
|
"}\n"
|
|
"\n"
|
|
"__global__ void run(int *out) {\n"
|
|
" out[0] = helper(21);\n"
|
|
"}\n";
|
|
if (single_file_battery("CUDA", src, CBM_LANG_CUDA, "k.cu",
|
|
"Function", NULL, "helper") != 0)
|
|
return 1;
|
|
return pipeline_battery("CUDA", "k.cu", src);
|
|
}
|
|
|
|
/* ── Rust ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: a `use` import, a struct + impl method, a free fn, in-body call.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 RED (cbm_pxc_has_cross_lsp is false for
|
|
* CBM_LANG_RUST, so the cross-LSP rescue never runs; tree-sitter enclosing-func
|
|
* walk alone falls back to Module).
|
|
*/
|
|
TEST(repro_grammar_core_rust) {
|
|
static const char src[] =
|
|
"use std::fmt;\n"
|
|
"\n"
|
|
"fn add(a: i32, b: i32) -> i32 {\n"
|
|
" a + b\n"
|
|
"}\n"
|
|
"\n"
|
|
"struct Calc {\n"
|
|
" base: i32,\n"
|
|
"}\n"
|
|
"\n"
|
|
"impl Calc {\n"
|
|
" fn compute(&self, x: i32) -> i32 {\n"
|
|
" add(self.base, x)\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("Rust", src, CBM_LANG_RUST, "lib.rs",
|
|
"Function", "Struct", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("Rust", "lib.rs", src);
|
|
}
|
|
|
|
/* ── Go ───────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: package + import, a struct + method, a free func, in-body call.
|
|
* Expected GREEN across the battery including dim 7 (func_kinds_go is in sync
|
|
* with the mature tree-sitter-go grammar; grep-validated correct). Regression
|
|
* guard: if dim 7 goes RED, Go callable attribution has broken.
|
|
*/
|
|
TEST(repro_grammar_core_go) {
|
|
static const char src[] =
|
|
"package main\n"
|
|
"\n"
|
|
"import \"fmt\"\n"
|
|
"\n"
|
|
"type Calc struct {\n"
|
|
" base int\n"
|
|
"}\n"
|
|
"\n"
|
|
"func add(a, b int) int {\n"
|
|
" return a + b\n"
|
|
"}\n"
|
|
"\n"
|
|
"func (c Calc) compute(x int) int {\n"
|
|
" fmt.Println(\"compute\")\n"
|
|
" return add(c.base, x)\n"
|
|
"}\n";
|
|
if (single_file_battery("Go", src, CBM_LANG_GO, "main.go",
|
|
"Function", "Struct", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("Go", "main.go", src);
|
|
}
|
|
|
|
/* ── Java ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: import, a class with two methods, callee inside the caller body.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 likely RED (java_lsp shows ~90 Module-
|
|
* sourced CALLS in the real graph; the minimal same-class method call is the
|
|
* simplest possible case and the audit evidence suggests it still falls back).
|
|
*/
|
|
TEST(repro_grammar_core_java) {
|
|
static const char src[] =
|
|
"import java.util.List;\n"
|
|
"\n"
|
|
"public class Calculator {\n"
|
|
" private int add(int a, int b) {\n"
|
|
" return a + b;\n"
|
|
" }\n"
|
|
"\n"
|
|
" public int compute(int x) {\n"
|
|
" return add(x, 1);\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("Java", src, CBM_LANG_JAVA, "Calculator.java",
|
|
"Method", "Class", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("Java", "Calculator.java", src);
|
|
}
|
|
|
|
/* ── C# ────────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: using directive, a class with two methods, in-body call.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 likely RED (analogous to Java per the
|
|
* breadth-suite gap evidence).
|
|
*/
|
|
TEST(repro_grammar_core_csharp) {
|
|
static const char src[] =
|
|
"using System;\n"
|
|
"\n"
|
|
"public class Calculator {\n"
|
|
" private int Add(int a, int b) {\n"
|
|
" return a + b;\n"
|
|
" }\n"
|
|
"\n"
|
|
" public int Compute(int x) {\n"
|
|
" return Add(x, 1);\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("C#", src, CBM_LANG_CSHARP, "Calculator.cs",
|
|
"Method", "Class", "Add") != 0)
|
|
return 1;
|
|
return pipeline_battery("C#", "Calculator.cs", src);
|
|
}
|
|
|
|
/* ── Kotlin ────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: import, a class with two methods, in-body call.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 likely RED (Kotlin LSP is hybrid; the
|
|
* enclosing-func attribution gap applies the same as the other OOP/LSP langs).
|
|
*/
|
|
TEST(repro_grammar_core_kotlin) {
|
|
static const char src[] =
|
|
"import kotlin.math.max\n"
|
|
"\n"
|
|
"class Calculator {\n"
|
|
" private fun add(a: Int, b: Int): Int {\n"
|
|
" return a + b\n"
|
|
" }\n"
|
|
"\n"
|
|
" fun compute(x: Int): Int {\n"
|
|
" return add(x, 1)\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("Kotlin", src, CBM_LANG_KOTLIN, "Calc.kt",
|
|
"Method", "Class", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("Kotlin", "Calc.kt", src);
|
|
}
|
|
|
|
/* ── Scala ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: import, a class with two methods, in-body call.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 likely RED (same enclosing-func gap;
|
|
* Scala has no dedicated cross-LSP rescue distinguishing it from the working
|
|
* set).
|
|
*/
|
|
TEST(repro_grammar_core_scala) {
|
|
static const char src[] =
|
|
"import scala.collection.mutable\n"
|
|
"\n"
|
|
"class Calculator {\n"
|
|
" private def add(a: Int, b: Int): Int = {\n"
|
|
" a + b\n"
|
|
" }\n"
|
|
"\n"
|
|
" def compute(x: Int): Int = {\n"
|
|
" add(x, 1)\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("Scala", src, CBM_LANG_SCALA, "Calc.scala",
|
|
"Method", "Class", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("Scala", "Calc.scala", src);
|
|
}
|
|
|
|
/* ── Swift ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: import, a struct with two methods, in-body call.
|
|
* Expected: dims 1-6 + 8 GREEN, dim 7 likely RED (same attribution gap for the
|
|
* tree-sitter-swift enclosing-func walk).
|
|
*/
|
|
TEST(repro_grammar_core_swift) {
|
|
static const char src[] =
|
|
"import Foundation\n"
|
|
"\n"
|
|
"struct Calculator {\n"
|
|
" func add(_ a: Int, _ b: Int) -> Int {\n"
|
|
" return a + b\n"
|
|
" }\n"
|
|
"\n"
|
|
" func compute(_ x: Int) -> Int {\n"
|
|
" return add(x, 1)\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("Swift", src, CBM_LANG_SWIFT, "Calc.swift",
|
|
"Method", "Struct", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("Swift", "Calc.swift", src);
|
|
}
|
|
|
|
/* ── Objective-C ───────────────────────────────────────────────────────────────
|
|
* Idiomatic: #import, an @interface/@implementation class, a free C helper, and
|
|
* the call made strictly inside a method body. Expected: dims 1-6 + 8 GREEN,
|
|
* dim 7 likely RED (Obj-C shares the C/C++ enclosing-func handling).
|
|
*/
|
|
TEST(repro_grammar_core_objc) {
|
|
static const char src[] =
|
|
"#import <Foundation/Foundation.h>\n"
|
|
"\n"
|
|
"static int helper(int x) {\n"
|
|
" return x * 2;\n"
|
|
"}\n"
|
|
"\n"
|
|
"@interface Calculator : NSObject\n"
|
|
"- (int)compute:(int)x;\n"
|
|
"@end\n"
|
|
"\n"
|
|
"@implementation Calculator\n"
|
|
"- (int)compute:(int)x {\n"
|
|
" return helper(x);\n"
|
|
"}\n"
|
|
"@end\n";
|
|
if (single_file_battery("Obj-C", src, CBM_LANG_OBJC, "Calc.m",
|
|
"Method", NULL, "helper") != 0)
|
|
return 1;
|
|
return pipeline_battery("Obj-C", "Calc.m", src);
|
|
}
|
|
|
|
/* ── D ─────────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: import, a struct + method, a free function, in-body call.
|
|
* Expected GREEN across the battery including dim 7 (D is a listed GREEN in the
|
|
* breadth callable-sourcing table). Uses CBM_LANG_DLANG.
|
|
*/
|
|
TEST(repro_grammar_core_dlang) {
|
|
static const char src[] =
|
|
"import std.stdio;\n"
|
|
"\n"
|
|
"int add(int a, int b)\n"
|
|
"{\n"
|
|
" return a + b;\n"
|
|
"}\n"
|
|
"\n"
|
|
"struct Calc\n"
|
|
"{\n"
|
|
" int base;\n"
|
|
" int compute(int x)\n"
|
|
" {\n"
|
|
" return add(base, x);\n"
|
|
" }\n"
|
|
"}\n";
|
|
if (single_file_battery("D", src, CBM_LANG_DLANG, "calc.d",
|
|
"Function", "Struct", "add") != 0)
|
|
return 1;
|
|
return pipeline_battery("D", "calc.d", src);
|
|
}
|
|
|
|
/* ── Suite ──────────────────────────────────────────────────────────────────── */
|
|
|
|
SUITE(repro_grammar_core) {
|
|
RUN_TEST(repro_grammar_core_c);
|
|
RUN_TEST(repro_grammar_core_cpp);
|
|
RUN_TEST(repro_grammar_core_cuda);
|
|
RUN_TEST(repro_grammar_core_rust);
|
|
RUN_TEST(repro_grammar_core_go);
|
|
RUN_TEST(repro_grammar_core_java);
|
|
RUN_TEST(repro_grammar_core_csharp);
|
|
RUN_TEST(repro_grammar_core_kotlin);
|
|
RUN_TEST(repro_grammar_core_scala);
|
|
RUN_TEST(repro_grammar_core_swift);
|
|
RUN_TEST(repro_grammar_core_objc);
|
|
RUN_TEST(repro_grammar_core_dlang);
|
|
}
|