Fix var binds in guard sequences

src/gradualizer_fmt.erl

@@ -202,7 +202,7 @@ format_type_error({type_error, op_type_too_precise, Op, Anno, Ty}, Opts) ->
        pp_type(Ty, Opts)]);
 format_type_error({type_error, arith_error, ArithOp, Anno, Ty1, Ty2}, Opts) ->
     io_lib:format(
-      "~sThe operator ~p~s is requires numeric arguments, but "
+      "~sThe operator ~p~s requires numeric arguments, but "
       "has arguments of type ~s and ~s~n",
       [format_location(Anno, brief, Opts),
        ArithOp,
@@ -211,7 +211,7 @@ format_type_error({type_error, arith_error, ArithOp, Anno, Ty1, Ty2}, Opts) ->
        pp_type(Ty2, Opts)]);
 format_type_error({type_error, int_error, ArithOp, Anno, Ty1, Ty2}, Opts) ->
     io_lib:format(
-      "~sThe operator ~p~s is requires integer arguments, but "
+      "~sThe operator ~p~s requires integer arguments, but "
       " has arguments of type ~s and ~s~n",
       [format_location(Anno, brief, Opts),
        ArithOp,

src/typechecker.erl

@@ -4593,7 +4593,7 @@ mirror_comp_op(Comm) -> Comm.
 -spec check_guard_expression(env(), term()) -> env().
 check_guard_expression(Env, {call, _, {atom, _, Fun}, Vars}) ->
     Env#env{venv = check_guard_call(Fun, Vars)};
-check_guard_expression(Env, {call, _, {remote,_, {atom, _, erlang},{atom, _, Fun}}, Vars}) ->
+check_guard_expression(Env, {call, _, {remote,_, {atom, _, erlang}, {atom, _, Fun}}, Vars}) ->
     Env#env{venv = check_guard_call(Fun, Vars)};
 check_guard_expression(Env, {op, _, Op, {var, _, Var}, {Tag, _, Value}})
   when ?is_comp_op(Op), Tag =:= integer orelse Tag =:= atom ->
@@ -4617,8 +4617,14 @@ check_guard_expression(Env, Guard) ->
 -spec check_guard(env(), list()) -> env().
 check_guard(Env, GuardSeq) ->
     RefTys = lists:foldl(fun(Guard, E) ->
-                             Ne = check_guard_expression(E, Guard),
-                             union_var_binds([Ne], E)
+                             NEnv = check_guard_expression(E, Guard),
+                             %% This is somewhat tricky.
+                             %% check_guard_expression/2 will return an env with just
+                             %% the types of vars used in the guard expression - we want these to
+                             %% refine any types previously in the env.
+                             %% We still want to keep types of vars not used in the guard expression,
+                             %% though, so we pass both NEnv and E to union_var_binds/2.
+                             union_var_binds([NEnv, E], E)
                          end, Env, GuardSeq),
     Env#env{venv = maps:merge(Env#env.venv, RefTys#env.venv)}.
 

test/should_pass/guard_sequences_pass.erl

@@ -0,0 +1,18 @@
+-module(guard_sequences_pass).
+
+-export([foo/2]).
+
+-spec foo(List1, List2) -> List2 when
+      List1 :: [Int],
+      List2 :: [Int|{Int,Int}],
+      Int :: integer().
+foo([], Acc) ->
+    Acc;
+foo([H | T], []) ->
+    foo(T, [H]);
+foo([H | T], [HA | TA]) when is_integer(HA), H == HA + 1 ->
+    foo(T, [{HA, H} | TA]);
+foo([H | T], [{HAB, HAE} | TA]) when H == HAE + 1 ->
+    foo(T, [{HAB, H} | TA]);
+foo([H | T], Acc) ->
+    foo(T, [H | Acc]).