anchor.diff:      end.
   
   lay_qualified_name([S| Ss1] = Ss,Ctxt) ->
  -    case erl_syntax:type(S) of
  +    case refac_syntax:type(S) of
         atom ->
  -	  case erl_syntax:atom_value(S) of
  +	  case refac_syntax:atom_value(S) of
   	    '' -> beside(text("."),lay_qualified_name_1(Ss1,Ctxt));
   	    _ -> lay_qualified_name_1(Ss,Ctxt)
   	  end;
  
positive.code: 	  beside(D1,D2);
        block_expr -> %% done;
  	  Ctxt1 = reset_prec(Ctxt),
  	  Body = erl_syntax:block_expr_body(Node),
  	  Es = seq(Body,floating(text(",")),Ctxt1,fun lay/2),
  	  sep([text("begin"),nest(Ctxt1#ctxt.sub_indent,lay_elems(fun refac_prettypr_0:sep/1,Es, Body)),text("end")]);
        catch_expr ->  %% done;
  	  {Prec,PrecR} = preop_prec('catch'),
  	  D = lay(erl_syntax:catch_expr_body(Node),set_prec(Ctxt,PrecR)),
  	  D1 = follow(text("catch"),D,Ctxt#ctxt.sub_indent),
  	  maybe_parentheses(D1,Prec,Ctxt);
        class_qualifier ->  %% done;
  	  Ctxt1 = set_prec(Ctxt,max_prec()),
  	  D1 = lay(erl_syntax:class_qualifier_argument(Node),Ctxt1),
  	  D2 = lay(erl_syntax:class_qualifier_body(Node),Ctxt1),
  	  beside(D1,beside(text(":"),D2));
        comment ->
  	  D = stack_comment_lines(erl_syntax:comment_text(Node)),
  	  %% Default padding for standalone comments is empty.
  	  case erl_syntax:comment_padding(Node) of
  	    none -> floating(break(D));
  	    P -> floating(break(beside(text(spaces(P)),D)))
  	  end;
        conjunction -> %% done;
  	  Es = seq(erl_syntax:conjunction_body(Node),floating(text(",")),reset_prec(Ctxt),fun lay/2),
  	  lay_elems(fun refac_prettypr_0:par/1, Es, erl_syntax:conjunction_body(Node));
        disjunction -> %% done;
  	  %% For clarity, we don't paragraph-format
  	  %% disjunctions; only conjunctions (see above).
            Es = seq(erl_syntax:disjunction_body(Node),floating(text(";")),reset_prec(Ctxt),fun lay/2),
            lay_elems(fun refac_prettypr_0:sep/1, Es, erl_syntax:disjunction_body(Node));
        error_marker ->  %% done;
  	  E = erl_syntax:error_marker_info(Node),
  	  beside(text("** "),beside(lay_error_info(E,reset_prec(Ctxt)),text(" **")));
        eof_marker -> empty();
        form_list -> 
  	  Es = seq(erl_syntax:form_list_elements(Node),none,reset_prec(Ctxt),fun lay/2),
  	  %% I leave this as it is. (HL).
  	  vertical_sep(text(""),Es);
        generator -> %% done;
  	  Ctxt1 = reset_prec(Ctxt),
  	  D1 = lay(erl_syntax:generator_pattern(Node),Ctxt1),
  	  D2 = lay(erl_syntax:generator_body(Node),Ctxt1),
  	  D1EndLn = get_end_line(erl_syntax:generator_pattern(Node)),
  	  D2StartLn =get_start_line(erl_syntax:generator_body(Node)),
  	  case (D1EndLn ==0) or (D2StartLn==0) of 
  	      true -> 
  		  par([D1,beside(text("<- "),D2)],Ctxt1#ctxt.break_indent);
  
negative.code: 		  end
  	  end;
        implicit_fun -> %%done;
  	  D = lay(refac_syntax:implicit_fun_name(Node),reset_prec(Ctxt)),
  	  beside(floating(text("fun ")),D);
        list_comp ->  %% done;
  	  Ctxt1 = reset_prec(Ctxt),
  	  D1 = lay(refac_syntax:list_comp_template(Node),Ctxt1),
  	  Es = seq(refac_syntax:list_comp_body(Node),floating(text(",")),Ctxt1,fun lay/2),
  	  D2 = lay_elems(fun refac_prettypr_0:par/1, Es, refac_syntax:list_comp_body(Node)),
  	  D1EndLn = get_end_line(refac_syntax:list_comp_template(Node)),
  	  D2StartLn = get_start_line(hd(refac_syntax:list_comp_body(Node))),
  	  D3 =  case (D2StartLn-D1EndLn==0) and (D1EndLn=/=0) of
  		    true -> beside(D1, beside(floating(text(" || ")),beside(D2,floating(text("]")))));
  		    _ ->  par([D1,beside(floating(text("|| ")),beside(D2,floating(text("]"))))])
  