[Bug] sol! type not found with free-standing struct

[DaniPopes]

Component

sol! macro

What version of Alloy are you on?

alloy-core 1.2.0

Operating System

None

Describe the bug

Handler.json:

[
    {
        "type": "function",
        "name": "handle",
        "inputs": [
            {
                "name": "foobar",
                "type": "tuple",
                "internalType": "struct IHandler.FooBar",
                "components": [
                    {
                        "name": "foo",
                        "type": "tuple",
                        "internalType": "struct Foo",
                        "components": [
                            {
                                "name": "newNumber",
                                "type": "uint256",
                                "internalType": "uint256"
                            }
                        ]
                    }
                ]
            }
        ],
        "outputs": [],
        "stateMutability": "nonpayable"
    }
]

Output:

error[E0412]: cannot find type `Foo` in this scope
 --> src/main.rs:3:1
  |
3 | / sol!(
4 | |     #[allow(missing_docs)]
5 | |     #[sol(rpc)]
6 | |     Handler,
7 | |     "../contracts/out/Handler.sol/Handler.json"
8 | | );
  | |_^ not found in this scope
  |
  = help: consider importing this struct:
          crate::Handler::Foo
  = note: this error originates in the macro `$crate::sol_types::sol` which comes from the expansion of the macro `sol` (in Nightly builds, run with -Z macro-backtrace for more info)

Originally reported by @kziemianek in #967

[mattsse]

The problem with this is that the expanded structure looks like

mod IHandler {
       pub struct FooBar {
            #[allow(missing_docs)]
            pub foo: <Foo as ::alloy_sol_types::SolType>::RustType,
        }   
}

mod Handler {

    pub struct Foo{} 

}

I tried to debug this a bit but got lost in the resolve+expand logic https://github.com/alloy-rs/core/compare/matt/debug-lib-expansion?expand=1 I moved the test files around so I can debug the macro, but idk how to proceed from here

sol!(
     Handler,
     "../json-abi/tests/abi/Handler.json"
 );
// <https://github.com/alloy-rs/core/issues/966>
#[test]
fn expand_handler() {
}

[ladislavdubravsky]

I think the issue here is that Handler.json mentions an IHandler inside ("internalType": "struct IHandler.FooBar",), whereas the Rust side macro invocation mentions a Handler (without the I):

sol!(
	#[allow(missing_docs)]
	#[sol(rpc)]
	Handler, <--------- this is different than type name inside Handler.json
	"contracts/out/Handler.sol/Handler.json"
);

When I change the Handler in macro invocation to IHandler, the error goes away.

One of the early steps in the macro expansion seems to be converting JSON input into Solidity input (and only then Solidity is turned into Rust types). Solidity generated with Handler in macro invocation ends up being:

library IHandler {
    struct FooBar {
        Foo foo;
    }
}

interface Handler {
    struct Foo {
        uint256 newNumber;
    }

    function handle(IHandler.FooBar memory foobar) external;
}

which obviously doesn't compile as Solidity.

Solidity generated with IHandler in macro invocation (i.e., matching the name in Solidity / JSON ABI) is fine (and then I think the Rust types will be as well):

interface IHandler {
    struct Foo {
        uint256 newNumber;
    }
    struct FooBar {
        Foo foo;
    }

    function handle(FooBar memory foobar) external;
}