Implement compiler AST rewrite infrastructure for parameterless witness()

[Copilot]

Adds infrastructure to support parameterless witness() calls that get rewritten into explicit witness constructor invocations during compilation. Currently, witness resolution requires the verbose witness(new Ty<T>() {}) syntax to work around type erasure.

Changes

Core API

• Added parameterless witness() method to TypeClasses that throws at runtime (expected to be rewritten during compilation)

AST Rewriting Infrastructure

• AstRewriter: Translates InstantiationPlan tree into JCTree method invocation chains using TreeMaker
• Builds proper JCFieldAccess and JCMethodInvocation nodes with recursive dependency handling
• WitnessCallTranslator: TreeTranslator that replaces parameterless witness() calls with generated constructor chains
• AstTransformListener: TaskListener hooked into ENTER/ANALYZE phases for AST transformation

Build Configuration

• Changed from maven.compiler.release to source/target (incompatible with --add-exports)
• Added exports for jdk.compiler internals: com.sun.tools.javac.{code,tree,util,processing,api}

Example

Intended usage pattern:

// Instead of: TestShow<String> show = witness(new Ty<TestShow<String>>() {});
TestShow<String> show = witness();  // Type inferred from context

Current Status

AST rewriting infrastructure is complete but TreeTranslator changes don't propagate to bytecode. Validation works correctly and reports unresolvable witnesses. Further investigation needed into javac phase timing or alternative approaches (compiler plugin, bytecode transformation).

All existing tests pass. Parameterless witness tests fail as expected until rewriting executes.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Implement compiler AST rewrite for parameterless witness()</issue_title>
<issue_description>It should be possible to expose a parameterless T witness() static method that gets rewritten into the expected witness constructor calls after witness resolution.

We only need the new Ty<>() {} "trick" because of type erasure. And of course because we can only resolve witnesses at runtime currently.

We can modify the AST with compiler internals like TreeMaker and casting to JCTree nodes, which are found in the JDK's lib/tools.jar.

In the current checker code, we ignore the success branch from the resolve() call. It contains an InstantiationPlan which describes the tree of WitnessConstructor that should be invoked to build the witness instance.

Roughly:

• Write a function that translates an InstantiationPlan tree into a JCTree of method call invocations. Each InstantiationPlan contains a WitnessConstructor which contains a ExecutableElement. This should be enough to build the JCTree?
• Then update the success branch of the resolve() call in the checker to replace the current AST node with the tree build from the function above. </issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Implement compiler AST rewrite for parameterless witness() #20

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.