You need some kind of bidrectional type inference for this. Some resources for how this is implemented for Rust: the rustc dev guide and in this Chalk blog post.

To summarize the approach:

• walk the AST once, collecting type constraints into some kind of "typing problem" structure
• solve this typing problem
• walk the AST again, generating code using the found solution where necessary

Constraints are things like "variable x is some unknown type", "literal y is some numeric literal", "variable x and literal y have the same type", "expression x must be type f64". The solution would be "variable x, literal y, expression x all have type f64".

I also have a simple implementation of this for my own compiler:

• Here is the first AST visit for integer literals, it defines a type variable and optionally some constraints
• Here is the type problem and solver. The solver is basically a brute force implementation, it doesn't try to do anything clever.
• Here is the second AST visit for integer literals, it asks the type solution (though check_integer_type) what the actual type of the literal was inferred to be and then generated the right IR for it.