This is my first stab at the constraint solver. It is only very
lightly tested and is not hooked in to the type checker yet.

When checking toplevel functions, call the constraint solver to work
out if the existential types are correct.

Unimplemented:

* Applying the substitution on the remaining types.
* Check that the remaining constraints are compatible with the
  constraints declared in the spec.

I fixed a few bugs in the process.

A variable might not have any constraints and that's fine!

Keeping the constraints when checking unions requires having a union
of constraints and the current implementation doesn't support that. So
right now we just drop the constraints.

This means that we currently don't report as many type errors as one
might expect.

The current representation for constraints cannot handle union types
so the constraints are dropped for now.

This means that some type errors will not be caught.

The function instantiate_fun_type now returns constraints which
have to be propagated.

This was caught by dialyzer

Test that a type var is solved to a union type given there's a case expression with multiple
patterns matching on an actual var the type var is assigned to.

…g typechecker.erl

This is probably a bug, since this record is not accessed directly in typechecker.erl,
but a crash in get_record_fields() still happened.

…rrors

The columns are always 1 as they're taken from the enclosing function location.

This is equivalent to the problem of typelib:remove_pos() which couldn't type check,
as it declared accepting a type(), whereas in fact some clauses it had matched type() inner nodes,
not the top level nodes. type() seems to be quite an unwieldy representation :/

…ndependent

…l.erl

Also add the `solve_constraints` attribute.

…known_problems/should_pass/poly_lists_map_constraints_should_pass.erl

…d_should_fail.erl to test/should_fail/poly_union_lower_bound_fail.erl

…to test/should_fail/poly_fail.erl

…st/known_problems/should_pass/poly_lists_map_constraints_should_pass.erl

…ection type

…ould_pass.erl -> test/should_pass/poly_lists_map_constraints_pass.erl

Based on:

    -spec get_unassigned_fields(Fields, All) -> [atom()] when
          Fields :: [record_field() | typed_record_field()],
          All :: [typed_record_field()].
    get_unassigned_fields(Fields, All) ->
        FieldNames = lists:flatmap(fun
                                       (?record_field(Field)) -> [Field];
                                       (?typed_record_field(Field)) -> [Field];
                                       %% We might run into values like this, which don't match above:
                                       %% {record_field, _, {var,{12,11},'_'}, _}
                                       (_) -> []
                                   end, Fields),
        AllNames = lists:map(fun (?typed_record_field(Field)) -> Field end, All),
        AllNames -- FieldNames.

Which currently raises:

    ebin/typechecker.beam: Lower bound record_field() | typed_record_field()
        of type variable A_typechecker_3467_838 on line 2026 is not a subtype
        of {A_typechecker_3467_838_typechecker_1226_848,
            A_typechecker_3467_838_typechecker_1226_849,
            A_typechecker_3467_838_typechecker_1226_850}

…o test/should_pass/poly_union_lower_bound_pass.erl

…pe/4

…empty constraints

…pe()

Based on:

    -spec combine_clauses_argument_constraints([type()], constraints:t(), map(), env()) -> constraints:t().
    combine_clauses_argument_constraints(ArgsTys, Cs, CatchAllArgs, Env) ->
        ArgsTyVars = lists:flatmap(fun
                                       ({var, _, Var}) -> [Var];
                                       (_) -> []
                                   end, ArgsTys),
        ...

The catch-all pattern does not register a constraint, while the tuple pattern does.
Because of that the type checker fails matching any type() with the funs clauses and returns a warning,
even though any type() instance will be handled by the fun.

…pe funs