Handoff: java metavariable-comparison + metavariable-type now structural
ober
7c44dbbaa01d32e3e2995d9d7d43c998955e8fe7
--- a/HANDOFF_OPUS_4_8.md +++ b/HANDOFF_OPUS_4_8.md @@ -151,17 +151,22 @@ languages, so closing them is the tip of the larger work: - **C / C++** (cpp 23 fixtures) — handled via `c-like-language?` (reachability filter etc.); migrating loses that the way Dart lost dead-catch. Hardest. - **Overfit-handler boundary (measured).** The per-language - `scan-{lang}-patterns-rule` / `scan-{lang}-taint-rule` handlers still fire and - still carry real work. With java's handlers disabled, only 16/42 java fixtures - pass via pure structural; the other 26 need the handlers and are almost all - taint (`taint_*`), metavariable-comparison (`metavar_comparison_*`), or - type-resolution (`metavar_type_*`, `metavariable_name_resolution`) cases. So - `wrapper-root-type?` made *pattern* matching real, but taint / - metavariable-comparison / type-resolution remain handler-side. Removing the - overfit handlers (and finishing dart/c/cpp) means porting those three feature - families onto the structural path — the substantial, well-scoped next project. - The same gap blocked the dart taint smoke cases. + **Overfit-handler paydown (in progress, java first).** Measured: with java's + patterns-rule handler disabled only 16/42 java fixtures passed structurally; + the rest were metavariable-comparison, metavariable-type, and taint. Now CLOSED + on the structural path for java: + - metavariable-comparison (`metavar_comparison_*`): java constant-prop regex + feeds the existing comparison evaluator (bitwise/logical already supported); + return_statement added to semicolon-trimmable-node?. + - metavariable-type (`metavar_type_not_java`): declared-type resolution already + worked; adding string_literal to string-literal-node? let `"..."` match java + string args (so the pattern-not fires). + `scan-java-patterns-rule` is now reduced to a single clause + (`metavariable-resolution-test`, which needs FQN resolution Foo->org.foo.Foo). + STILL handler-side (the deep remaining work): java TAINT (`scan-java-taint-rule` + — real dataflow, incl. type-aware assume-safe, best-fit-sink, lambda/getter + propagators), java FQN resolution, and the analogous handlers for the other + migrated languages. The dart taint smoke cases hit the same taint gap. The original concern below (regex matcher limitations) still applies only to the languages still on `generic-language?`: `generic-language?`