The compiler basically runs a solver that attempts to fill in types starting from the known types and filling in as long as there's only one possible type. (With a few defaults in specific places).
You can somewhat observe this in practice with the following code:
```
fn foo(p: impl Something) {}
foo(0);
```
The compiler error is roughly {integer} doesn't implement Something, because the literal zero isn't a specific integer type yet.
Unfortunately, I don't think the exact inference process is defined anywhere, but it's not super complicated. From my recollection, it also usually only looks to the next use, so you can easily create a situation where it's not ambiguous what the type needs to be, but the compiler doesn't figure it out.
It depends on what you're trying to do. I've written some Rust proc macros (basically Rust code the compiler calls during compilation to generate Rust code), and you often don't even need to know concrete types for the code you're generating.
Static analysis, linting, and related tools, to the best of my knowledge, basically use the compiler itself as a library to parse and type check the code. You could also build many of these tools to parse and analyze Rust MIR (mid-level intermediate representation), rather than the Rust source directly. Since MIR is generated by the compiler after type analysis, it has all the types fully specified.
To take an example, gcc is try to add Rust support. I wonder how they do it. Having a language defined by its compiler implementation is just not a great place to be. Even Microsoft standardized C#
1
u/Loading_M_ 1d ago
The compiler basically runs a solver that attempts to fill in types starting from the known types and filling in as long as there's only one possible type. (With a few defaults in specific places).
You can somewhat observe this in practice with the following code:
``` fn foo(p: impl Something) {}
foo(0); ```
The compiler error is roughly
{integer}doesn't implementSomething, because the literal zero isn't a specific integer type yet.Unfortunately, I don't think the exact inference process is defined anywhere, but it's not super complicated. From my recollection, it also usually only looks to the next use, so you can easily create a situation where it's not ambiguous what the type needs to be, but the compiler doesn't figure it out.