anchor.diff:  type_anno(nil) -> nil.
   
   -spec type_anno(term(), term()) -> term().
  -type_anno(atom, Value) -> {atom, Value};
  -type_anno(float, Value) -> {float, Value};
  -type_anno(integer, Value) -> {integer, Value}.
  +type_anno(atom, Value) when is_atom(Value) -> {atom, Value};
  +type_anno(float, Value) when is_float(Value)  -> {float, Value};
  +type_anno(integer, Value) when is_integer(Value) -> {integer, Value}.
   
   -spec type_anno(term(), term(), term(), term()) -> term().
   type_anno(tuple, Size, Exact, Elements) when is_integer(Size), Size >= 0,
  
positive.code:     end;
  verify_arg_type(Lbl, Reg, GivenType, #vst{ft=Ft}) ->
      case gb_trees:lookup({Lbl, Reg}, Ft) of
          {value, bool} when GivenType =:= {atom, true};
                             GivenType =:= {atom, false};
                             GivenType =:= {atom, []} ->
              %% We don't yet support upgrading true/false to bool, so we
              %% assume unknown atoms can be bools when validating calls.
              ok;
          {value, #ms{}} ->
              %% Functions that accept match contexts also accept all other
              %% terms. This will change once we support union types.
              ok;
          {value, RequiredType} ->
              case meet(GivenType, RequiredType) of
                  none -> error({bad_arg_type, Reg, GivenType, RequiredType});
                  _ -> ok
              end;
          none ->
              ok
      end.
  
  allocate(Tag, Stk, Heap, Live, #vst{current=#st{numy=none}=St}=Vst0) ->
      verify_live(Live, Vst0),
  
negative.code:     join_bool(A);
  join({atom,A}, bool) ->
      join_bool(A);
  join({atom,A}, {atom,B}) when is_boolean(A), is_boolean(B) ->
      bool;
  join({atom,_}, {atom,_}) ->
      {atom,[]};
  join(#ms{id=Id1,valid=B1,slots=Slots1},
  