path: root/lib/tools/emacs/test.erl.indented

%% -*- erlang -*-
%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2009-2016. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%

%%%-------------------------------------------------------------------
%%% File    : test.erl
%%% Author  : Dan Gudmundsson <[email protected]>
%%% Description :   Test emacs mode indention and font-locking
%%%                 this file is intentionally not indented.
%%%                 Copy the file and indent it and you should end up with test.erl.indented
%%% Created :  6 Oct 2009 by Dan Gudmundsson <[email protected]>
%%%-------------------------------------------------------------------

%% Start off with syntax highlighting you have to verify this by looking here 
%% and see that the code looks alright

-module(test).
-compile(export_all).

%% Used to cause an "Unbalanced parentheses" error.
foo(M) ->
    M#{a :=<<"a">>
      ,b:=1}.
foo() ->
    #{a =><<"a">>
     ,b=>1}.

%% Module attributes should be highlighted

-export([t/1]).
-record(record1, {a, 
		  b, 
		  c
		 }).
-record(record2, {
	  a,
	  b
	 }).

-record(record3, {a = 8#42423 bor
		      8#4234,
		  b = 8#5432 
		      bor 2#1010101
		  c = 123 +
		      234,
		  d}).

-record(record4, {
	  a = 8#42423 bor
	      8#4234,
	  b = 8#5432 
	      bor 2#1010101
	  c = 123 +
	      234,
	  d}).

-record(record5, { a = 1 :: integer()
		 , b = foobar :: atom()
		 }).

-define(MACRO_1, macro).
-define(MACRO_2(_), macro).

-spec t(integer()) -> any().

-type ann() :: Var :: integer(). 
-type ann2() :: Var :: 
	    'return' 
	  | 'return_white_spaces' 
	  | 'return_comments'
	  | 'text' | ann(). 
-type paren() :: 
	(ann2()). 
-type t1() :: atom(). 
-type t2() :: [t1()]. 
-type t3(Atom) :: integer(Atom). 
-type t4() :: t3(foobar). 
-type t5() :: {t1(), t3(foo)}. 
-type t6() :: 1 | 2 | 3 | 
	      'foo' | 'bar'. 
-type t7() :: []. 
-type t71() :: [_]. 
-type t8() :: {any(),none(),pid(),port(),
	       reference(),float()}. 
-type t9() :: [1|2|3|foo|bar] | 
	      list(a | b | c) | t71(). 
-type t10() :: {1|2|3|foo|t9()} | {}. 
-type t11() :: 1..2. 
-type t13() :: maybe_improper_list(integer(), t11()). 
-type t14() :: [erl_scan:foo() | 
		%% Should be highlighted
		term() |
		bool() |
		byte() |
		char() |
		non_neg_integer() | nonempty_list() |
		pos_integer() |
		neg_integer() |
		number() |
		list() |
		nonempty_improper_list() | nonempty_maybe_improper_list() |
		maybe_improper_list() | string() | iolist() | byte() |
		module() |
		mfa() 	|
		node() 	|
		timeout() |
		no_return() |
		%% Should not be highlighted
		nonempty_() | nonlist() | 
		erl_scan:bar(34, 92) | t13() | m:f(integer() | <<_:_*16>>)].


-type t15() :: {binary(),<<>>,<<_:34>>,<<_:_*42>>,
		<<_:3,_:_*14>>,<<>>} | [<<>>|<<_:34>>|<<_:16>>|
					<<_:3,_:_*1472>>|<<_:19,_:_*14>>| <<_:34>>|
					<<_:34>>|<<_:34>>|<<_:34>>]. 
-type t16() :: fun(). 
-type t17() :: fun((...) -> paren()). 
-type t18() :: fun(() -> t17() | t16()). 
-type t19() :: fun((t18()) -> t16()) |
	       fun((nonempty_maybe_improper_list('integer', any())|
		    1|2|3|a|b|<<_:3,_:_*14>>|integer()) ->
			  nonempty_maybe_improper_list('integer', any())|
			  1|2|3|a|b|<<_:3,_:_*14>>|integer()). 
-type t20() :: [t19(), ...]. 
-type t21() :: tuple(). 
-type t21(A) :: A. 
-type t22() :: t21(integer()). 
-type t23() :: #rec1{}. 
-type t24() :: #rec2{a :: t23(), b :: [atom()]}. 
-type t25() :: #rec3{f123 :: [t24() | 
			      1|2|3|4|a|b|c|d| 
			      nonempty_maybe_improper_list(integer, any())]}. 
-type t26() :: #rec4{ a :: integer()
		    , b :: any()
		    }.
-type t27() :: { integer()
	       , atom()
	       }.
-type t99() ::
	{t2(),t4(),t5(),t6(),t7(),t8(),t10(),t14(),
	 t15(),t20(),t21(), t22(),t25()}. 
-spec t1(FooBar :: t99()) -> t99();
	(t2()) -> t2();
	(t4()) -> t4() when is_subtype(t4(), t24);
	(t23()) -> t23() when is_subtype(t23(), atom()),
			      is_subtype(t23(), t14());
	(t24()) -> t24() when is_subtype(t24(), atom()),
			      is_subtype(t24(), t14()),
			      is_subtype(t24(), t4()).

-spec over(I :: integer()) -> R1 :: foo:typen();
	  (A :: atom()) -> R2 :: foo:atomen();
	  (T :: tuple()) -> R3 :: bar:typen().

-spec mod:t2() -> any(). 

-spec handle_cast(Cast :: {'exchange', node(), [[name(),...]]} 
			| {'del_member', name(), pid()},
		  #state{}) -> {'noreply', #state{}}.

-spec handle_cast(Cast :: 
		    {'exchange', node(), [[name(),...]]} 
		  | {'del_member', name(), pid()},
		  #state{}) -> {'noreply', #state{}}.

-spec all(fun((T) -> boolean()), List :: [T]) ->
		 boolean() when is_subtype(T, term()). % (*)

-spec get_closest_pid(term()) -> 
			     Return :: pid()
				     | {'error', {'no_process', term()}
					| {'no_such_group', term()}}.

-spec add( X :: integer()
	 , Y :: integer()
	 ) -> integer().

-opaque attributes_data() :: 
	  [{'column', column()} | {'line', info_line()} |
	   {'text', string()}] |  {line(),column()}.   
-record(r,{
	  f1 :: attributes_data(),
	  f222 = foo:bar(34, #rec3{}, 234234234423, 
			 aassdsfsdfsdf, 2234242323) :: 
		   [t24() | 1|2|3|4|a|b|c|d| 
		    nonempty_maybe_improper_list(integer, any())],
	  f333 :: [t24() | 1|2|3|4|a|b|c|d| 
		   nonempty_maybe_improper_list(integer, any())],
	  f3 = x:y(),
	  f4 = x:z() :: t99(),
	  f17 :: 'undefined',
	  f18 :: 1 | 2 | 'undefined',
	  f19 = 3 :: integer()|undefined,
	  f5 = 3 :: undefined|integer()}). 

-record(state, {
	  sequence_number = 1          :: integer()
	 }).


highlighting(X)			  % Function definitions should be highlighted
  when is_integer(X) ->	  % and so should `when' and `is_integer' be
    %% Highlighting
    %% Various characters (we keep an `atom' after to see that highlighting ends)
    $a,atom,			  % Characters should be marked
    "string",atom,		  % and strings
    'asdasd',atom,		  % quote should be atoms??
    'VaV',atom,
    'aVa',atom,
    '\'atom',atom,
    'atom\'',atom,
    'at\'om',atom,
    '#1',atom,

    $", atom,					% atom should be ok
    $', atom, 

    "string$", atom,  "string$", atom,  		% currently buggy I know...
    "string\$", atom,   				% workaround for bug above

    "char $in string", atom, 

    'atom$', atom,  'atom$', atom,
    'atom\$', atom,

    'char $in atom', atom,

    $[, ${, $\\, atom,
    ?MACRO_1,
    ?MACRO_2(foo),

    %% Numerical constants
    16#DD,					% AD Should not be highlighted
    32#dd,					% AD Should not be highlighted
    32#ddAB,				        % AD Should not be highlighted
    32#101,				        % AD Should not be highlighted
    32#ABTR,				        % AD Should not be highlighted

    %% Variables
    Variables = lists:foo(),
    _Variables = lists:foo(),                      % AD
    AppSpec = Xyz/2,
    Module42 = Xyz(foo, bar),
    Module:foo(),
    _Module:foo(),				% AD
    FooÅÅ = lists:reverse([tl,hd,tl,hd]),	% AD Should highlight FooÅÅ
    _FooÅÅ = 42,				% AD Should highlight _FooÅÅ

    %% Bifs
    erlang:registered(),
    registered(),
    hd(tl(tl(hd([a,b,c])))),
    erlang:anything(lists),
    %% Guards
    is_atom(foo), is_float(2.3), is_integer(32), is_number(4323.3),
    is_function(Fun), is_pid(self()), 
    not_a_guard:is_list([]),
    %% Other Types

    atom,			  % not (currently) hightlighted
    234234, 
    234.43,

    [list, are, not, higlighted],    
    {nor, is, tuple},
    ok.

%%%
%%%  Indentation
%%%

%%%  Left

%%   Indented

						%    Right


indent_basics(X, Y, Z) 
  when X > 42,
       Z < 13;
       Y =:= 4711 ->
    %% comments
						% right comments
    case lists:filter(fun(_, AlongName, 
			  B, 
			  C) ->
			      true
		      end, 
		      [a,v,b])
    of
	[] ->
	    Y = 5 * 43,
	    ok;
	[_|_] -> 
	    Y = 5 * 43,
	    ok
    end,
    Y,
    %% List, tuples and binaries
    [a, 
     b, c
    ],
    [ a, 
      b, c
    ],

    [
     a,
     b
    ],
    {a, 
     b,c
    },
    { a, 
      b,c
    },

    {
      a,
      b
    },

    <<1:8,
      2:8
    >>,
    <<
      1:8,
      2:8
    >>,
    << 1:8,
       2:8
    >>,

    (a,
     b,
     c
    ),

    ( a,
      b,
      c
    ),


    (
      a,
      b,
      c
    ),

    call(2#42423 bor 
	     #4234,
	 2#5432,
	 other_arg),
    ok;
indent_basics(Xlongname, 
	      #struct{a=Foo,
		      b=Bar}, 
	      [X|
	       Y]) ->
    testing_next_clause,
    ok;
indent_basics(					% AD added clause
  X, 						% not sure how this should look
  Y,
  Z)
  when
      X < 42, Z > 13;
      Y =:= 4711 ->
    foo;
indent_basics(X, Y, Z) when			% AD added clause
      X < 42, Z > 13;				% testing when indentation
      Y =:= 4711 ->
    foo;
indent_basics(X, Y, Z)				% AD added clause
  when						% testing when indentation
      X < 42, Z > 13;				% unsure about this one
      Y =:= 4711 ->
    foo.



indent_nested() ->
    [
     {foo, 2, "string"},
     {bar, 3, "another string"}
    ].


indent_icr(Z) -> 				% icr = if case receive
    %% If
    if Z >= 0 ->
	    X = 43 div 4,
	    foo(X);
       Z =< 10 ->
	    X = 43 div 4,
	    foo(X);
       Z == 5 orelse
       Z == 7 ->
	    X = 43 div 4,
	    foo(X);
       true ->
	    if_works
    end,
    %% Case
    case {Z, foo, bar} of
	{Z,_,_} ->
	    X = 43 div 4,
	    foo(X);
	{Z,_,_}	when
	      Z =:= 42 ->				% AD line should be indented as a when
	    X = 43 div 4,
	    foo(X);
	{Z,_,_}
	  when Z < 10 ->			% AD when should be indented
	    X = 43 div 4,
	    foo(X);
	{Z,_,_}
	  when					% AD when should be indented
	      Z < 10				% and the guards should follow when
	      andalso				% unsure about how though
	      true ->
	    X = 43 div 4,
	    foo(X)
    end,
    %% begin
    begin
	sune,
	X = 74234 + foo(8456) +
	    345 div 43,
	ok
    end,


    %% receive
    receive 
	{Z,_,_} ->
	    X = 43 div 4,
	    foo(X);
	Z ->
	    X = 43 div 4,
	    foo(X) 
    end,
    receive
	{Z,_,_} ->
	    X = 43 div 4,
	    foo(X);
	Z 					% AD added clause
	  when Z =:= 1 ->			% This line should be indented by 2
	    X = 43 div 4,
	    foo(X);
	Z when					% AD added clause
	      Z =:= 2 ->				% This line should be indented by 2
	    X = 43 div 4,
	    foo(X);
	Z ->
	    X = 43 div 4,
	    foo(X) 
    after infinity ->
	    foo(X),
	    asd(X),
	    5*43
    end,
    receive
    after 10 -> 
	    foo(X),
	    asd(X),
	    5*43
    end,
    ok.

indent_fun() ->
    %% Changed fun to one indention level
    Var = spawn(fun(X) 
		      when X == 2;
			   X > 10 -> 
			hello,
			case Hello() of 
			    true when is_atom(X) -> 
				foo;
			    false ->
				bar
			end;
		   (Foo) when is_atom(Foo), 
			      is_integer(X) ->
			X = 6* 45,
			Y = true andalso
			    kalle
		end),
    %% check EEP37 named funs
    Fn1 = fun Fact(N) when N > 0 ->
		  F = Fact(N-1),
		  N * F;
	      Fact(0) ->
		  1
	  end,
    %% check anonymous funs too
    Fn2 = fun(0) ->
		  1;
	     (N) ->
		  N
	  end,
    ok.

indent_try_catch() ->
    try
	io:format(stdout, "Parsing file ~s, ", 
		  [St0#leex.xfile]),
	{ok,Line3,REAs,Actions,St3} = 
	    parse_rules(Xfile, Line2, Macs, St2)
    catch
	exit:{badarg,R} ->
	    foo(R),
	    io:format(stdout, 
		      "ERROR reason ~p~n",
		      R);
	error:R 				% AD added clause
	  when R =:= 42 ->			% when should be indented
	    foo(R);
	error:R 				% AD added clause
	  when					% when should be indented
	      R =:= 42 ->				% but unsure about this (maybe 2 more)
	    foo(R);
	error:R when				% AD added clause
	      R =:= foo ->				% line should be 2 indented (works)
	    foo(R);
	error:R ->
	    foo(R),
	    io:format(stdout, 
		      "ERROR reason ~p~n",
		      R)
    after
	foo('after'),
	file:close(Xfile)
    end;
indent_try_catch() ->
    try
	foo(bar)
    of
	X when true andalso
	       kalle ->
	    io:format(stdout, "Parsing file ~s, ",
		      [St0#leex.xfile]),
	    {ok,Line3,REAs,Actions,St3} =
		parse_rules(Xfile, Line2, Macs, St2);
	X 					% AD added clause
	  when false andalso			% when should be 2 indented
	       bengt ->
	    gurka();
	X when					% AD added clause
	      false andalso				% line should be 2 indented
	      not bengt ->
	    gurka();
	X ->
	    io:format(stdout, "Parsing file ~s, ",
		      [St0#leex.xfile]),
	    {ok,Line3,REAs,Actions,St3} =
		parse_rules(Xfile, Line2, Macs, St2)
    catch
	exit:{badarg,R} ->
	    foo(R),
	    io:format(stdout, 
		      "ERROR reason ~p~n",
		      R);
	error:R ->
	    foo(R),
	    io:format(stdout, 
		      "ERROR reason ~p~n",
		      R)
    after
	foo('after'),
	file:close(Xfile),
	bar(with_long_arg,
	    with_second_arg)
    end;
indent_try_catch() ->
    try foo()
    after 
	foo(),
	bar(with_long_arg,
	    with_second_arg)
    end.

indent_catch() ->
    D = B +
	float(43.1),

    B = catch oskar(X),

    A = catch (baz + 
		   bax),
    catch foo(),

    C = catch B + 
	float(43.1),

    case catch foo(X) of
	A ->
	    B
    end,

    case
	catch foo(X)
    of
	A ->
	    B
    end,

    case
	foo(X)
    of
	A ->
	    catch B,
	    X
    end,

    try sune of
	_ -> foo
    catch _:_ -> baf
    end,

    try
	sune
    of
	_ ->
	    X = 5,
	    (catch foo(X)),
	    X + 10
    catch _:_ -> baf
    end,

    try
	(catch sune)
    of
	_ ->
            catch foo()  %% BUGBUG can't handle catch inside try without parentheses
    catch _:_ ->
	    baf
    end,

    try
	(catch exit())
    catch
	_ ->
	    catch baf()
    end,
    ok.

indent_binary() ->
    X = lists:foldr(fun(M) ->
			    <<Ma/binary, " ">>
		    end, [], A),
    A = <<X/binary, 0:8>>,
    B.


indent_comprehensions() ->
    %% I don't have a good idea how we want to handle this 
    %% but they are here to show how they are indented today.
    Result1 = [X || 
		  #record{a=X} <- lists:seq(1, 10),
		  true = (X rem 2)
	      ],
    Result2 = [X || <<X:32,_:32>> <= <<0:512>>,
		    true = (X rem 2)
	      ],

    Binary1 = << <<X:8>> || 
		  #record{a=X} <- lists:seq(1, 10),
		  true = (X rem 2)
	      >>,

    Binary2 = << <<X:8>> || <<X:32,_:32>> <= <<0:512>>,
			    true = (X rem 2)
	      >>,
    ok.

%% This causes an error in earlier erlang-mode versions.
foo() ->
    [#foo{
	foo = foo}].

%% Record indentation
some_function_with_a_very_long_name() ->
    #'a-long-record-name-like-it-sometimes-is-with-asn.1-records'{
       field1=a,
       field2=b},
    case dummy_function_with_a_very_very_long_name(x) of
	#'a-long-record-name-like-it-sometimes-is-with-asn.1-records'{
	   field1=a,
	   field2=b} ->
	    ok;
	Var = #'a-long-record-name-like-it-sometimes-is-with-asn.1-records'{
		 field1=a,
		 field2=b} ->
	    Var#'a-long-record-name-like-it-sometimes-is-with-asn.1-records'{
	      field1=a,
	      field2=b};
	#xyz{
	   a=1,
	   b=2} ->
	    ok
    end.

another_function_with_a_very_very_long_name() ->
    #rec{
       field1=1,
       field2=1}.

some_function_name_xyz(xyzzy, #some_record{
				 field1=Field1,
				 field2=Field2}) ->
    SomeVariable = f(#'Some-long-record-name'{
			field_a = 1,
			'inter-xyz-parameters' =
			    #'Some-other-very-long-record-name'{
			       field2 = Field1,
			       field2 = Field2}}),
    {ok, SomeVariable}.

commas_first() ->
    {abc, [ {some_var, 1}
	  , {some_other_var, 2}
	  , {erlang_ftw, 9}
	  , {erlang_cookie, 'cookie'}
	  , {cmds,
	     [ {one,   "sudo ls"}
	     , {one,   "sudo ls"}
	     , {two,   "sudo ls"}
	     , {three, "sudo ls"}
	     , {four,  "sudo ls"}
	     , {three, "sudo ls"}
	     ] }
	  , {ssh_username, "yow"}
	  , {cluster,
	     [ {aaaa, [ {"10.198.55.12" , "" }
		      , {"10.198.55.13" , "" }
		      ] }
	     , {bbbb, [ {"10.198.55.151", "" }
		      , {"10.198.55.123", "" }
		      , {"10.198.55.34" , "" }
		      , {"10.198.55.85" , "" }
		      , {"10.198.55.67" , "" }
		      ] }
	     , {cccc, [ {"10.198.55.68" , "" }
		      , {"10.198.55.69" , "" }
		      ] }
	     ] }
	  ]
    }.


%% this used to result in a scan-sexp error
[{
 }].

%% this used to result in 2x the correct indentation within the function
%% body, due to the function name being mistaken for a keyword
catcher(N) ->
    try generate_exception(N) of
	Val -> {N, normal, Val}
    catch
	throw:X -> {N, caught, thrown, X};
	exit:X -> {N, caught, exited, X};
	error:X -> {N, caught, error, X}
    end.