Repository navigation
Count an argument's expected type when it's what the call's solution has to be - #445
Merged
Merged
Conversation
…has to be An argument's expected type that references the callee's generics isn't a hint when the call's own expected type is a type of its own and no argument still to be compiled can add to those generics: the call's solution has to fit it then, and a narrower solution for the argument only narrows the call's, which its expected type then still holds. So `wrap(map(fn(x) => x, 5))` with `(5, Int)` expected compiles, as `wrap::<5>(map::<5, 5>(...))` does.
… it are covariant Where values of the callee's generics flow into the argument, such as `A` in `fn(a: A) -> B`, what they're inferred as so far can be wider than the call's solution, which would ask more of the argument than the call does: `compose(feed(fn(x) => x, five_only))` then gave `feed` the `fn(value: 5) -> Int` type that `compose` can't take. Where they only flow out of it, a solution that fits the call's final expected type has the argument fit it, whatever the arguments after it add, since the type only bounds them from above, so that condition is dropped: `wrap_after(map(fn(x) => x, 5), 6)` with `(5 | 6, Int)` expected compiles, as `wrap_after::<5 | 6>(map::<5, 5>(...), 6)` does.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Part of #362 (step 13e, layer 6 of 9).
An argument's expected type that references the callee's generics was always a hint. Now it counts when both of these hold:
occurs_contravariantly).In that case a solution that fits the call's expected type has the argument fit it. So
let r: (5, Int) = wrap(map(fn(x) => x, 5))solvesmapfor5, aswrap::<5>(map::<5, 5>(...))does.compose'sAinfn(a: A) -> B, what's inferred so far can be wider than the solution. The fuzzer foundchain::<Int | nil, 5, Int>(compose(fn(_x) => 5), compose(feed(fn(x) => x, five_only)), nil)regressing on an earlier version, and it's pinned asargument_whose_generic_takes_values.wrap_after(map(fn(x) => x, 5), 6)with(5 | 6, Int)expected compiles, aswrap_after::<5 | 6>(map::<5, 5>(...), 6)does.wrap(map(fn(x) => x, 5)) is (5, Int)still checks at runtime (argument_of_a_guarded_call).wrap_with(1, map(fn(x) => x, 5))with(5, Int)expected: no instantiation gives it that type. It's pinned.The stack (#362 step 13e, layers 6–9)
These layers close the gaps that the merged 13e layers (#438–#442) left, so the generics campaign ends with no follow-ups. Each layer is its own PR:
6. An argument's expected type counts when it's what the call's solution has to be:
wrap(map(fn(x) => x, 5))with(5, Int)expected.7. List items past the end of the expected pairs:
first(([2], [3, make()])).8. Struct fields and inner pairs keep a lambda parameter's generic references.
9. A lambda's shared or caller generics are instantiated when its body captures none of their values: the soundness limits that 13e pinned.
Fuzzer, per layer.
infer-fuzz --compareagainst baselines from main6aea07a5, on all four configurations (generators 1 and 2, seeds0..4000and4000..8000). Every layer has 0 regressions and 0 unsound variants, changes no variant that main infers, and leaks no{generic N}. Newly inferred variants, cumulative: 37 (6), 40 (7), 40 (8), 143 (9). The top PR has the full table.Breaking changes. None. No program that compiles on main changes its type, CLVM output or diagnostics. Pinned errors that now compile get the type that explicit instantiation gives, and each is a test.
Review. Three rounds:
Any; it's limited to a real list end now.T(x as T), so a value escaped with the wrong type. It's fixed, and pinned innames_the_callers_generic.one_of_two_lambdas_captures.Mutant rule. Every mutant ran in a scratch worktree, under
timeout 120, after a separate build step.Note
Medium Risk
This changes which types are inferred for calls with lambda arguments, list literals and field accesses, all in the compiler's call inference. A mistake would reject valid programs or accept unsound ones. The risk is limited by these points:
Changes by area:
call_inference.rs: the hint rule for an argument's expected type; which lambda parameters are instantiated (generic_parameter_types,names_restored_generics); instantiation in the alternative solve.lambda.rs:LambdaParameterandLambdaBody::captures_generics.list.rs: items past the end of the expected pairs.field.rs:wrapped_atandkeeps_reference.compiler.rs:ArgumentFrame::lambda_parametersholdsLambdaParameters.rue-hir/database.rs:next_hir_id,hirs_betweenandsymbol_count.tests/types/generic_inference_*: new tests and moved pins.