anchor.diff:      {M=:=M1, external, MFA};
   mfa(_, _M) -> false.
   
  -expr({'if', _Line, Cs}, S) ->
  +expr({'if', _Anno, Cs}, S) ->
       clauses(Cs, S);
  -expr({'case', _Line, E, Cs}, S) ->
  +expr({'case', _Anno, E, Cs}, S) ->
       S1 = expr(E, S),
       clauses(Cs, S1);
  -expr({'receive', _Line, Cs}, S) ->
  +expr({'receive', _Anno, Cs}, S) ->
       clauses(Cs, S);
  -expr({'receive', _Line, Cs, To, ToEs}, S) ->
  +expr({'receive', _Anno, Cs, To, ToEs}, S) ->
       S1 = expr(To, S),
       S2 = expr(ToEs, S1),
       clauses(Cs, S2);
  -expr({'try',_Line,Es,Scs,Ccs,As}, S) ->
  +expr({'try',_Anno,Es,Scs,Ccs,As}, S) ->
       S1 = expr(Es, S),
       S2 = clauses(Scs, S1),
       S3 = clauses(Ccs, S2),
       expr(As, S3);
  -expr({'fun', Line, {function, {atom,_,Mod},
  +expr({'fun', Anno, {function, {atom,_,Mod},
   		    {atom,_,Name},
   		    {integer,_,Arity}}}, S) ->
       %% New format in R15. M:F/A (literals).
  -    As = lists:duplicate(Arity, {atom, Line, foo}),
  -    external_call(Mod, Name, As, Line, false, S);
  -expr({'fun', Line, {function, Mod, Name, {integer,_,Arity}}}, S) ->
  +    As = lists:duplicate(Arity, {atom, Anno, foo}),
  +    external_call(Mod, Name, As, Anno, false, S);
  +expr({'fun', Anno, {function, Mod, Name, {integer,_,Arity}}}, S) ->
       %% New format in R15. M:F/A (one or more variables).
  -    As = lists:duplicate(Arity, {atom, Line, foo}),
  -    external_call(erlang, apply, [Mod, Name, list2term(As)], Line, true, S);
  -expr({'fun', Line, {function, Mod, Name, _Arity}}, S) ->
  +    As = lists:duplicate(Arity, {atom, Anno, foo}),
  +    external_call(erlang, apply, [Mod, Name, list2term(As)], Anno, true, S);
  +expr({'fun', Anno, {function, Mod, Name, _Arity}}, S) ->
       %% New format in R15. M:F/A (one or more variables).
  -    As = {var, Line, '_'},
  -    external_call(erlang, apply, [Mod, Name, As], Line, true, S);
  +    As = {var, Anno, '_'},
  +    external_call(erlang, apply, [Mod, Name, As], Anno, true, S);
   %% Only abstract_v1 and abstract_v2.
  -expr({'fun', Line, {function, Name, Arity}, _Extra}, S) ->
  +expr({'fun', Anno, {function, Name, Arity}, _Extra}, S) ->
       %% Added in R8.
  -    handle_call(local, S#xrefr.module, Name, Arity, Line, S);
  -expr({'fun', _Line, {clauses, Cs}, _Extra}, S) ->
  +    handle_call(local, S#xrefr.module, Name, Arity, Anno, S);
  +expr({'fun', _Anno, {clauses, Cs}, _Extra}, S) ->
       clauses(Cs, S);
   %% End abstract_v1 and abstract_v2.
  -expr({'fun', Line, {function, Name, Arity}}, S) ->
  +expr({'fun', Anno, {function, Name, Arity}}, S) ->
       %% Added in OTP 20.
  -    handle_call(local, S#xrefr.module, Name, Arity, Line, S);
  -expr({'fun', _Line, {clauses, Cs}}, S) ->
  +    handle_call(local, S#xrefr.module, Name, Arity, Anno, S);
  +expr({'fun', _Anno, {clauses, Cs}}, S) ->
       clauses(Cs, S);
  -expr({named_fun, _Line, '_', Cs}, S) ->
  +expr({named_fun, _Anno, '_', Cs}, S) ->
       clauses(Cs, S);
  -expr({named_fun, _Line, Name, Cs}, S) ->
  +expr({named_fun, _Anno, Name, Cs}, S) ->
       S1 = S#xrefr{funvars = [Name | S#xrefr.funvars]},
       clauses(Cs, S1);
  -expr({call, Line, {atom, _, Name}, As}, S) ->
  -    S1 = handle_call(local, S#xrefr.module, Name, length(As), Line, S),
  +expr({call, Anno, {atom, _, Name}, As}, S) ->
  +    S1 = handle_call(local, S#xrefr.module, Name, length(As), Anno, S),
       expr(As, S1);
  -expr({call, Line, {remote, _Line, {atom,_,Mod}, {atom,_,Name}}, As}, S) ->
  -    external_call(Mod, Name, As, Line, false, S);
  -expr({call, Line, {remote, _Line, Mod, Name}, As}, S) ->
  +expr({call, Anno, {remote, _Anno, {atom,_,Mod}, {atom,_,Name}}, As}, S) ->
  +    external_call(Mod, Name, As, Anno, false, S);
  +expr({call, Anno, {remote, _Anno, Mod, Name}, As}, S) ->
       %% Added in R8.
  -    external_call(erlang, apply, [Mod, Name, list2term(As)], Line, true, S);
  -expr({call, Line, F, As}, S) ->
  -    external_call(erlang, apply, [F, list2term(As)], Line, true, S);
  -expr({match, _Line, {var,_,Var}, {'fun', _, {clauses, Cs}, _Extra}}, S) ->
  +    external_call(erlang, apply, [Mod, Name, list2term(As)], Anno, true, S);
  +expr({call, Anno, F, As}, S) ->
  +    external_call(erlang, apply, [F, list2term(As)], Anno, true, S);
  +expr({match, _Anno, {var,_,Var}, {'fun', _, {clauses, Cs}, _Extra}}, S) ->
       %% This is what is needed in R7 to avoid warnings for the functions
       %% that are passed around by the "expansion" of list comprehension.
       S1 = S#xrefr{funvars = [Var | S#xrefr.funvars]},
       clauses(Cs, S1);
  -expr({match, _Line, {var,_,Var}, {'fun', _, {clauses, Cs}}}, S) ->
  +expr({match, _Anno, {var,_,Var}, {'fun', _, {clauses, Cs}}}, S) ->
       %% OTP 20. Exposed because sys_pre_expand is no longer run.
       S1 = S#xrefr{funvars = [Var | S#xrefr.funvars]},
       clauses(Cs, S1);
  -expr({match, _Line, {var,_,Var}, {named_fun, _, _, _} = Fun}, S) ->
  +expr({match, _Anno, {var,_,Var}, {named_fun, _, _, _} = Fun}, S) ->
       %% OTP 20. Exposed because sys_pre_expand is no longer run.
       S1 = S#xrefr{funvars = [Var | S#xrefr.funvars]},
       expr(Fun, S1);
  -expr({match, _Line, {var,_,Var}, E}, S) ->
  +expr({match, _Anno, {var,_,Var}, E}, S) ->
       %% Used for resolving code like
       %%     Args = [A,B], apply(m, f, Args)
       S1 = S#xrefr{matches = [{Var, E} | S#xrefr.matches]},
       expr(E, S1);
  -expr({op, _Line, 'orelse', Op1, Op2}, S) ->
  +expr({op, _Anno, 'orelse', Op1, Op2}, S) ->
       expr([Op1, Op2], S);
  -expr({op, _Line, 'andalso', Op1, Op2}, S) ->
  +expr({op, _Anno, 'andalso', Op1, Op2}, S) ->
       expr([Op1, Op2], S);
  -expr({op, Line, Op, Operand1, Operand2}, S) ->
  -    external_call(erlang, Op, [Operand1, Operand2], Line, false, S);
  -expr({op, Line, Op, Operand}, S) ->
  -    external_call(erlang, Op, [Operand], Line, false, S);
  +expr({op, Anno, Op, Operand1, Operand2}, S) ->
  +    external_call(erlang, Op, [Operand1, Operand2], Anno, false, S);
  +expr({op, Anno, Op, Operand}, S) ->
  +    external_call(erlang, Op, [Operand], Anno, false, S);
   expr(T, S) when is_tuple(T) ->
       expr(tuple_to_list(T), S);
   expr([E | Es], S) ->
  
positive.code: 	{type, _} ->
  	    expr(ArgsList, S1);
  	{apply2, [{tuple, _, [M,F]}, ArgsTerm]} ->
  	    eval_args(M, F, ArgsTerm, Line, S1, ArgsList, []);
  	{1, [{tuple, _, [M,F]} | R]} ->	% R = [] unless spawn_opt
  	    eval_args(M, F, list2term([]), Line, S1, ArgsList, R);
  	{2, [Node, {tuple, _, [M,F]} | R]} -> % R = [] unless spawn_opt
  	    eval_args(M, F, list2term([]), Line, S1, ArgsList, [Node | R]);
  	{3, [M, F, ArgsTerm | R]} -> % R = [] unless spawn_opt
  	    eval_args(M, F, ArgsTerm, Line, S1, ArgsList, R);
  	{4, [Node, M, F, ArgsTerm | R]} -> % R = [] unless spawn_opt
  	    eval_args(M, F, ArgsTerm, Line, S1, ArgsList, [Node | R]);
  	{debug4, [M, F, ArgsTerm, _]} ->
  	    eval_args(M, F, ArgsTerm, Line, S1, ArgsList, []);
  	_Else -> % apply2, 1 or 2
  	    check_funarg(W, ArgsList, Line, S1)
      end.
  
  eval_args(Mod, Fun, ArgsTerm, Line, S, ArgsList, Extra) ->
      {IsSimpleCall, M, F} = mod_fun(Mod, Fun),
      case term2list(ArgsTerm, [], S) of
  	undefined ->
  	    S1 = unresolved(M, F, -1, Line, S),
  	    expr(ArgsList, S1);
  	ArgsList2 when not IsSimpleCall ->
  	    S1 = unresolved(M, F, length(ArgsList2), Line, S),
  	    expr(ArgsList, S1);
  	ArgsList2 when IsSimpleCall ->
  	    S1 = expr(Extra, S),
  	    external_call(M, F, ArgsList2, Line, false, S1)
      end.
  
  mod_fun({atom,_,M1}, {atom,_,F1}) -> {true, M1, F1};
  
negative.code:     #xrefr{funvars = FunVars, matches = Matches} = S,
      clauses(Cls, FunVars, Matches, S).
  
  clauses([{clause, _Anno, _H, G, B} | Cs], FunVars, Matches, S) ->
      S1 = case S#xrefr.builtins_too of
  	     true -> expr(G, S);
  	     false -> S
  