anchor.diff:  enter_type_lists([], [], Map) ->
     Map.
   
  -enter_type_list([{Key, Val}|Left], Map) ->
  -  Map1 = enter_type(Key, Val, Map),
  -  enter_type_list(Left, Map1);
  -enter_type_list([], Map) ->
  -  Map.
  -
   enter_type(Key, Val, MS) ->
     case cerl:is_literal(Key) of
       true -> MS;
  
positive.code: 
  %%----------------------------------------
  
  handle_module(Tree, Map, State) ->
    %% By not including the variables in scope we can assure that we
    %% will get the current function type when using the variables.
    Defs = cerl:module_defs(Tree),
    PartFun = fun({_Var, Fun}) ->
  		state__is_escaping(get_label(Fun), State)
  	    end,
    {Defs1, Defs2} = lists:partition(PartFun, Defs),
    Letrec = cerl:c_letrec(Defs1, cerl:c_int(42)),
    {State1, Map1, _FunTypes} = traverse(Letrec, Map, State),
    %% Also add environments for the other top-level functions.
    VarTypes = [{Var, state__fun_type(Fun, State1)} || {Var, Fun} <- Defs],
    EnvMap = enter_type_list(VarTypes, Map),
    FoldFun = fun({_Var, Fun}, AccState) ->
  		state__update_fun_env(Fun, EnvMap, AccState)
  	    end,
    State2 = lists:foldl(FoldFun, State1, Defs2),
    {State2, Map1, t_any()}.
  
  %%----------------------------------------
  
  handle_receive(Tree, Map, State) ->
    Clauses = cerl:receive_clauses(Tree),
    Timeout = cerl:receive_timeout(Tree),
    State1 =
      case is_race_analysis_enabled(State) of
        true ->
  	{RaceList, RaceListSize} = get_race_list_and_size(State),
          state__renew_race_list([beg_case|RaceList],
                                 RaceListSize + 1, State);
        false -> State
      end,
    {MapList, State2, ReceiveType, Warns} =
      handle_clauses(Clauses, ?no_arg, t_any(), t_any(), State1, [], Map,
  		   [], [], []),
    State3 = lists:foldl(fun({T,R,M,F}, S) -> state__add_warning(S,T,R,M,F) end,
  		       State2, Warns),
    Map1 = join_maps(MapList, Map),
    {State4, Map2, TimeoutType} = traverse(Timeout, Map1, State3),
    Opaques = State4#state.opaques,
    case (t_is_atom(TimeoutType, Opaques) andalso
  	(t_atom_vals(TimeoutType, Opaques) =:= ['infinity'])) of
      true ->
        {State4, Map2, ReceiveType};
      false ->
        Action = cerl:receive_action(Tree),
        {State5, Map3, ActionType} = traverse(Action, Map, State4),
        Map4 = join_maps([Map3, Map1], Map),
        Type = t_sup(ReceiveType, ActionType),
        {State5, Map4, Type}
    end.
  
  %%----------------------------------------
  
  handle_try(Tree, Map, State) ->
    Arg = cerl:try_arg(Tree),
    EVars = cerl:try_evars(Tree),
  
negative.code:       false -> State
      end,
    Map0 = mark_as_fresh(Pats, Map),
    Map1 = bind_subst(Arg, Pats, Map0),
    BindRes =
      case t_is_none(ArgType0) of
        true ->
  