[code-reflection] RFR: Support storing the code that builds the code model [v18]

[Maurizio Cimadamore]

On Wed, 12 Mar 2025 18:00:05 GMT, Mourad Abbay <mabbay at openjdk.org> wrote:

>> In this PR we allow the user to decide how to store the code model. The first option is `TEXT`, if this is selected, we store the textual representation of the code model. The second option is `CODE_BUILDR`, if this is selected, we store the code that builds the code model. All work done here is around the second option, because the first option is already supported.
>
> Mourad Abbay has updated the pull request with a new target base due to a merge or a rebase. The incremental webrev excludes the unrelated changes brought in by the merge/rebase. The pull request contains 20 additional commits since the last revision:
> 
>  - Merge branch 'code-reflection' into code-model-storage-option
>  - Load OpFactory and TypeElementFactory before invocation of opMethod only if the opMethod has there params.
>  - Fix the remaining compiler tests failures
>  - Fix some of the test failures (3 remains)
>  - Fix the remaining test failures of SwitchExpressionTest2
>  - Fix almost all test failures of SwitchExpressionTest2 (one remaining)
>  - Pass arrayType instead of eleType in OpBuilder.buildArray
>  - Ensure that block params are inserted in the correct order
>  - Add missing imports
>  - Merge branch 'code-reflection' into code-model-storage-option
>  - ... and 10 more: https://git.openjdk.org/babylon/compare/54ef7f9c...966005ce

src/jdk.incubator.code/share/classes/jdk/incubator/code/internal/CodeModelToAST.java line 160:

> 158:                 var argTypes = new ListBuffer<Type>();
> 159:                 for (Value operand : newOp.operands()) {
> 160:                     argTypes.add(typeElementToType(operand.type()));

This seems wrong -- and is related to the point I made above -- the type of the operands here are the types of the actual arguments of the constructor calls. So, if you have:

class Foo {
     Foo(String string) { ... }
 }
 ```
 
 the method type of the constructor call has to say `Foo(String)`. But if you "infer" the type of the constructor argument from the actual argument, if the call is like this:
 
 ```
 new Foo(null)
 ```
 
We should probably use the op's `constructorType` to derive the type of the invoked constructor? (You use that to determine the constructor's owner type)

-------------

PR Review Comment: https://git.openjdk.org/babylon/pull/305#discussion_r1993690501