Merge branch 'bjorn/compiler/cuddle-with-tests'

* bjorn/compiler/cuddle-with-tests:
  inline_SUITE: Don't start a slave node
  Correct test_lib:is_cloned_mod/1
  sys_core_fold_lists: Propagate annotations in expansion of lists functions
  Parallelize compile_SUITE:bc_options/1
  Remove the optimized_guard/1 test case

5 files changed, 122 insertions, 181 deletions

diff --git a/lib/compiler/src/sys_core_fold_lists.erl b/lib/compiler/src/sys_core_fold_lists.erl
index 9867fab46a..e93b435011 100644
--- a/lib/compiler/src/sys_core_fold_lists.erl
+++ b/lib/compiler/src/sys_core_fold_lists.erl
@@ -37,22 +37,27 @@ call(#c_call{anno=Anno}, lists, all, [Arg1,Arg2]) ->
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
     Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
-    CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
+    CC1 = #c_clause{anno=Anno,
+                    pats=[#c_literal{val=true}], guard=#c_literal{val=true},
 		    body=#c_apply{anno=Anno, op=Loop, args=[Xs]}},
-    CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
+    CC2 = #c_clause{anno=Anno,
+                    pats=[#c_literal{val=false}], guard=#c_literal{val=true},
 		    body=#c_literal{val=false}},
-    CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
+    CC3 = #c_clause{anno=Anno,
+                    pats=[X], guard=#c_literal{val=true},
 		    body=match_fail(Anno, Err1)},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_case{arg=#c_apply{anno=Anno, op=F, args=[X]},
 				clauses = [CC1, CC2, CC3]}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno,
+                   pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=1}]},
 		   body=#c_literal{val=true}},
     Err2 = #c_tuple{es=[#c_literal{val='function_clause'}, F, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^all',1}}|Anno], Err2)},
     Fun = #c_fun{vars=[Xs],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -66,16 +71,21 @@ call(#c_call{anno=Anno}, lists, any, [Arg1,Arg2]) ->
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
     Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
-    CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
+    CC1 = #c_clause{anno=Anno,
+                    pats=[#c_literal{val=true}], guard=#c_literal{val=true},
 		    body=#c_literal{val=true}},
-    CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
+    CC2 = #c_clause{anno=Anno,
+                    pats=[#c_literal{val=false}], guard=#c_literal{val=true},
 		    body=#c_apply{anno=Anno, op=Loop, args=[Xs]}},
-    CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
+    CC3 = #c_clause{anno=Anno,
+                    pats=[X], guard=#c_literal{val=true},
 		    body=match_fail(Anno, Err1)},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_case{arg=#c_apply{anno=Anno, op=F, args=[X]},
 				clauses = [CC1, CC2, CC3]}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno,
+                   pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=1}]},
@@ -94,16 +104,17 @@ call(#c_call{anno=Anno}, lists, foreach, [Arg1,Arg2]) ->
     F = #c_var{name='F'},
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_seq{arg=#c_apply{anno=Anno, op=F, args=[X]},
 			       body=#c_apply{anno=Anno, op=Loop, args=[Xs]}}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno, pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=1}]},
 		   body=#c_literal{val=ok}},
     Err = #c_tuple{es=[#c_literal{val='function_clause'}, F, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^foreach',1}}|Anno], Err)},
     Fun = #c_fun{vars=[Xs],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -117,7 +128,8 @@ call(#c_call{anno=Anno}, lists, map, [Arg1,Arg2]) ->
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
     H = #c_var{name='H'},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_let{vars=[H], arg=#c_apply{anno=Anno,
 						      op=F,
 						      args=[X]},
@@ -126,7 +138,7 @@ call(#c_call{anno=Anno}, lists, map, [Arg1,Arg2]) ->
 					    tl=#c_apply{anno=Anno,
 							op=Loop,
 							args=[Xs]}}}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno, pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=1}]},
@@ -146,7 +158,8 @@ call(#c_call{anno=Anno}, lists, flatmap, [Arg1,Arg2]) ->
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
     H = #c_var{name='H'},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_let{vars=[H],
 			       arg=#c_apply{anno=Anno, op=F, args=[X]},
 			       body=#c_call{anno=[compiler_generated|Anno],
@@ -156,13 +169,13 @@ call(#c_call{anno=Anno}, lists, flatmap, [Arg1,Arg2]) ->
 						  #c_apply{anno=Anno,
 							   op=Loop,
 							   args=[Xs]}]}}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno, pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=1}]},
 		   body=#c_literal{val=[]}},
     Err = #c_tuple{es=[#c_literal{val='function_clause'}, F, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^flatmap',1}}|Anno], Err)},
     Fun = #c_fun{vars=[Xs],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -177,11 +190,13 @@ call(#c_call{anno=Anno}, lists, filter, [Arg1,Arg2]) ->
     X = #c_var{name='X'},
     B = #c_var{name='B'},
     Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
-    CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
+    CC1 = #c_clause{anno=Anno,
+                    pats=[#c_literal{val=true}], guard=#c_literal{val=true},
 		    body=#c_cons{anno=[compiler_generated], hd=X, tl=Xs}},
-    CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
+    CC2 = #c_clause{anno=Anno,
+                    pats=[#c_literal{val=false}], guard=#c_literal{val=true},
 		    body=Xs},
-    CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
+    CC3 = #c_clause{anno=Anno, pats=[X], guard=#c_literal{val=true},
 		    body=match_fail(Anno, Err1)},
     Case = #c_case{arg=B, clauses = [CC1, CC2, CC3]},
     C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
@@ -192,13 +207,15 @@ call(#c_call{anno=Anno}, lists, filter, [Arg1,Arg2]) ->
 							op=Loop,
 							args=[Xs]},
 					   body=Case}}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno,
+                   pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=1}]},
 		   body=#c_literal{val=[]}},
     Err2 = #c_tuple{es=[#c_literal{val='function_clause'}, F, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno,
+                   pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^filter',1}}|Anno], Err2)},
     Fun = #c_fun{vars=[Xs],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -212,19 +229,20 @@ call(#c_call{anno=Anno}, lists, foldl, [Arg1,Arg2,Arg3]) ->
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
     A = #c_var{name='A'},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_apply{anno=Anno,
 				 op=Loop,
 				 args=[Xs, #c_apply{anno=Anno,
 						    op=F,
 						    args=[X, A]}]}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno, pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=2}]},
 		   body=A},
     Err = #c_tuple{es=[#c_literal{val='function_clause'}, F, A, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^foldl',2}}|Anno], Err)},
     Fun = #c_fun{vars=[Xs, A],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -238,19 +256,20 @@ call(#c_call{anno=Anno}, lists, foldr, [Arg1,Arg2,Arg3]) ->
     Xs = #c_var{name='Xs'},
     X = #c_var{name='X'},
     A = #c_var{name='A'},
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=#c_apply{anno=Anno,
 				 op=F,
 				 args=[X, #c_apply{anno=Anno,
 						   op=Loop,
 						   args=[Xs, A]}]}},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno, pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=2}]},
 		   body=A},
     Err = #c_tuple{es=[#c_literal{val='function_clause'}, F, A, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^foldr',2}}|Anno], Err)},
     Fun = #c_fun{vars=[Xs, A],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -266,13 +285,14 @@ call(#c_call{anno=Anno}, lists, mapfoldl, [Arg1,Arg2,Arg3]) ->
     Avar = #c_var{name='A'},
     Match =
 	fun (A, P, E) ->
-		C1 = #c_clause{pats=[P], guard=#c_literal{val=true}, body=E},
+		C1 = #c_clause{anno=Anno, pats=[P], guard=#c_literal{val=true}, body=E},
 		Err = #c_tuple{es=[#c_literal{val='badmatch'}, X]},
-		C2 = #c_clause{pats=[X], guard=#c_literal{val=true},
+		C2 = #c_clause{anno=Anno, pats=[X], guard=#c_literal{val=true},
 			       body=match_fail(Anno, Err)},
 		#c_case{arg=A, clauses=[C1, C2]}
 	end,
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno,
+                   pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 		   body=Match(#c_apply{anno=Anno, op=F, args=[X, Avar]},
 			      #c_tuple{es=[X, Avar]},
 %%% Tuple passing version
@@ -292,7 +312,7 @@ call(#c_call{anno=Anno}, lists, mapfoldl, [Arg1,Arg2,Arg3]) ->
 %%% 				     body=#c_values{es=[#c_cons{hd=X, tl=Xs},
 %%% 							A]}}
 			     )},
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno, pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=2}]},
@@ -302,7 +322,7 @@ call(#c_call{anno=Anno}, lists, mapfoldl, [Arg1,Arg2,Arg3]) ->
 %%% Multiple-value version
 %%% 		   body=#c_values{es=[#c_literal{val=[]}, A]}},
     Err = #c_tuple{es=[#c_literal{val='function_clause'}, F, Avar, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^mapfoldl',2}}|Anno], Err)},
     Fun = #c_fun{vars=[Xs, Avar],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
@@ -326,13 +346,13 @@ call(#c_call{anno=Anno}, lists, mapfoldr, [Arg1,Arg2,Arg3]) ->
     Avar = #c_var{name='A'},
     Match =
 	fun (A, P, E) ->
-		C1 = #c_clause{pats=[P], guard=#c_literal{val=true}, body=E},
+		C1 = #c_clause{anno=Anno, pats=[P], guard=#c_literal{val=true}, body=E},
 		Err = #c_tuple{es=[#c_literal{val='badmatch'}, X]},
-		C2 = #c_clause{pats=[X], guard=#c_literal{val=true},
+		C2 = #c_clause{anno=Anno, pats=[X], guard=#c_literal{val=true},
 			       body=match_fail(Anno, Err)},
 		#c_case{arg=A, clauses=[C1, C2]}
 	end,
-    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+    C1 = #c_clause{anno=Anno, pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
 %%% Tuple passing version
 		   body=Match(#c_apply{anno=Anno,
 				       op=Loop,
@@ -352,7 +372,8 @@ call(#c_call{anno=Anno}, lists, mapfoldr, [Arg1,Arg2,Arg3]) ->
 %%% 					  #c_values{es=[#c_cons{hd=X, tl=Xs},
 %%% 						        A]})}
 		  },
-    C2 = #c_clause{pats=[#c_literal{val=[]}],
+    C2 = #c_clause{anno=Anno,
+                   pats=[#c_literal{val=[]}],
 		   guard=#c_call{module=#c_literal{val=erlang},
 				 name=#c_literal{val=is_function},
 				 args=[F, #c_literal{val=2}]},
@@ -362,7 +383,7 @@ call(#c_call{anno=Anno}, lists, mapfoldr, [Arg1,Arg2,Arg3]) ->
 %%% Multiple-value version
 %%% 		   body=#c_values{es=[#c_literal{val=[]}, A]}},
     Err = #c_tuple{es=[#c_literal{val='function_clause'}, F, Avar, Xs]},
-    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+    C3 = #c_clause{anno=Anno, pats=[Xs], guard=#c_literal{val=true},
 		   body=match_fail([{function_name,{'lists^mapfoldr',2}}|Anno], Err)},
     Fun = #c_fun{vars=[Xs, Avar],
 		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
diff --git a/lib/compiler/test/compile_SUITE.erl b/lib/compiler/test/compile_SUITE.erl
index 7452466666..dade5d20d5 100644
--- a/lib/compiler/test/compile_SUITE.erl
+++ b/lib/compiler/test/compile_SUITE.erl
@@ -33,7 +33,7 @@
 	 other_output/1, kernel_listing/1, encrypted_abstr/1,
 	 strict_record/1, utf8_atoms/1, utf8_functions/1, extra_chunks/1,
 	 cover/1, env/1, core_pp/1, tuple_calls/1,
-	 core_roundtrip/1, asm/1, optimized_guards/1,
+	 core_roundtrip/1, asm/1,
 	 sys_pre_attributes/1, dialyzer/1,
 	 warnings/1, pre_load_check/1, env_compiler_options/1,
          bc_options/1, deterministic_include/1, deterministic_paths/1
@@ -50,7 +50,7 @@ all() ->
      binary, makedep, cond_and_ifdef, listings, listings_big,
      other_output, kernel_listing, encrypted_abstr, tuple_calls,
      strict_record, utf8_atoms, utf8_functions, extra_chunks,
-     cover, env, core_pp, core_roundtrip, asm, optimized_guards,
+     cover, env, core_pp, core_roundtrip, asm,
      sys_pre_attributes, dialyzer, warnings, pre_load_check,
      env_compiler_options, custom_debug_info, bc_options,
      custom_compile_info, deterministic_include, deterministic_paths].
@@ -1174,85 +1174,6 @@ do_asm(Beam, Outdir) ->
 	    error
     end.
 
-%% Make sure that guards are fully optimized. Guards should
-%% should use 'test' instructions, not 'bif' instructions.
-
-optimized_guards(_Config) ->
-    TestBeams = get_unique_beam_files(),
-    test_lib:p_run(fun(F) -> do_opt_guards(F) end, TestBeams).
-
-do_opt_guards(Beam) ->
-    {ok,{M,[{abstract_code,{raw_abstract_v1,A}}]}} =
-	beam_lib:chunks(Beam, [abstract_code]),
-    try
-	{ok,M,Asm} = compile:forms(A, ['S']),
-	do_opt_guards_mod(Asm)
-    catch Class:Error:Stk ->
-	    io:format("~p: ~p ~p\n~p\n", [M,Class,Error,Stk]),
-	    error
-    end.
-
-do_opt_guards_mod({Mod,_Exp,_Attr,Asm,_NumLabels}) ->
-    case do_opt_guards_fs(Mod, Asm) of
-	[] ->
-	    ok;
-	[_|_]=Bifs ->
-	    io:format("ERRORS FOR ~p:\n~p\n", [Mod,Bifs]),
-	    error
-    end.
-
-do_opt_guards_fs(Mod, [{function,Name,Arity,_,Is}|Fs]) ->
-    Bifs0 = do_opt_guards_fun(Is),
-
-    %% The compiler does not attempt to optimize 'xor'.
-    %% Therefore, ignore all functions that use 'xor' in
-    %% a guard.
-    Bifs = case lists:any(fun({bif,'xor',_,_,_}) -> true;
-			     (_) -> false
-			  end, Bifs0) of
-	       true -> [];
-	       false -> Bifs0
-	   end,
-
-    %% Filter out the allowed exceptions.
-    FA = {Name,Arity},
-    case {Bifs,is_exception(Mod, FA)} of
-	{[_|_],true} ->
-	    io:format("~p:~p/~p IGNORED:\n~p\n",
-		      [Mod,Name,Arity,Bifs]),
-	    do_opt_guards_fs(Mod, Fs);
-	{[_|_],false} ->
-	    [{FA,Bifs}|do_opt_guards_fs(Mod, Fs)];
-	{[],false} ->
-	    do_opt_guards_fs(Mod, Fs);
-	{[],true} ->
-	    io:format("Redundant exception for ~p:~p/~p\n",
-		      [Mod,Name,Arity]),
-	    error(redundant)
-    end;
-do_opt_guards_fs(_, []) -> [].
-
-do_opt_guards_fun([{bif,Name,{f,F},As,_}=I|Is]) when F =/= 0 ->
-    Arity = length(As),
-    case erl_internal:comp_op(Name, Arity) orelse
-	erl_internal:bool_op(Name, Arity) orelse
-	erl_internal:new_type_test(Name, Arity) of
-	true ->
-	    [I|do_opt_guards_fun(Is)];
-	false ->
-	    do_opt_guards_fun(Is)
-    end;
-do_opt_guards_fun([_|Is]) ->
-    do_opt_guards_fun(Is);
-do_opt_guards_fun([]) -> [].
-
-is_exception(guard_SUITE, {'-complex_not/1-fun-4-',1}) -> true;
-is_exception(guard_SUITE, {'-complex_not/1-fun-5-',1}) -> true;
-is_exception(guard_SUITE, {bad_guards,1}) -> true;
-is_exception(guard_SUITE, {nested_not_2b,6}) -> true; %% w/o type optimization
-is_exception(guard_SUITE, {nested_not_2b,2}) -> true; %% with type optimization
-is_exception(_, _) -> false.
-
 sys_pre_attributes(Config) ->
     DataDir = proplists:get_value(data_dir, Config),
     File = filename:join(DataDir, "attributes.erl"),
@@ -1469,44 +1390,49 @@ env_compiler_options(_Config) ->
 bc_options(Config) ->
     DataDir = proplists:get_value(data_dir, Config),
 
-    101 = highest_opcode(DataDir, small_float, [no_get_hd_tl,no_line_info]),
-
-    103 = highest_opcode(DataDir, big,
-                         [no_put_tuple2,
-                          no_get_hd_tl,no_ssa_opt_record,
-                          no_line_info,no_stack_trimming]),
-
-    125 = highest_opcode(DataDir, small_float,
-                         [no_get_hd_tl,no_line_info,no_ssa_opt_float]),
-
-    132 = highest_opcode(DataDir, small,
-                         [no_put_tuple2,no_get_hd_tl,no_ssa_opt_record,
-                          no_ssa_opt_float,no_line_info,no_bsm3]),
-
-    153 = highest_opcode(DataDir, small, [r20]),
-    153 = highest_opcode(DataDir, small, [r21]),
-
-    136 = highest_opcode(DataDir, big, [no_put_tuple2,no_get_hd_tl,
-                                        no_ssa_opt_record,no_line_info]),
-
-    153 = highest_opcode(DataDir, big, [no_put_tuple2,no_get_hd_tl,
-                                        no_ssa_opt_record]),
-    153 = highest_opcode(DataDir, big, [r16]),
-    153 = highest_opcode(DataDir, big, [r17]),
-    153 = highest_opcode(DataDir, big, [r18]),
-    153 = highest_opcode(DataDir, big, [r19]),
-    153 = highest_opcode(DataDir, small_float, [r16]),
-    153 = highest_opcode(DataDir, small_float, []),
-
-    158 = highest_opcode(DataDir, small_maps, [r17]),
-    158 = highest_opcode(DataDir, small_maps, [r18]),
-    158 = highest_opcode(DataDir, small_maps, [r19]),
-    158 = highest_opcode(DataDir, small_maps, [r20]),
-    158 = highest_opcode(DataDir, small_maps, [r21]),
-
-    164 = highest_opcode(DataDir, small_maps, []),
-    164 = highest_opcode(DataDir, big, []),
-
+    L = [{101, small_float, [no_get_hd_tl,no_line_info]},
+         {103, big, [no_put_tuple2,no_get_hd_tl,no_ssa_opt_record,
+                     no_line_info,no_stack_trimming]},
+         {125, small_float, [no_get_hd_tl,no_line_info,no_ssa_opt_float]},
+
+         {132, small, [no_put_tuple2,no_get_hd_tl,no_ssa_opt_record,
+                       no_ssa_opt_float,no_line_info,no_bsm3]},
+
+         {153, small, [r20]},
+         {153, small, [r21]},
+
+         {136, big, [no_put_tuple2,no_get_hd_tl,
+                     no_ssa_opt_record,no_line_info]},
+
+         {153, big, [no_put_tuple2,no_get_hd_tl, no_ssa_opt_record]},
+         {153, big, [r16]},
+         {153, big, [r17]},
+         {153, big, [r18]},
+         {153, big, [r19]},
+         {153, small_float, [r16]},
+         {153, small_float, []},
+
+         {158, small_maps, [r17]},
+         {158, small_maps, [r18]},
+         {158, small_maps, [r19]},
+         {158, small_maps, [r20]},
+         {158, small_maps, [r21]},
+
+         {164, small_maps, []},
+         {164, big, []}
+        ],
+
+    Test = fun({Expected,Mod,Options}) ->
+                   case highest_opcode(DataDir, Mod, Options) of
+                       Expected ->
+                           ok;
+                       Got ->
+                           io:format("*** module ~p, options ~p => got ~p; expected ~p\n",
+                                     [Mod,Options,Got,Expected]),
+                           error
+                   end
+           end,
+    test_lib:p_run(Test, L),
     ok.
 
 highest_opcode(DataDir, Mod, Opt) ->
diff --git a/lib/compiler/test/inline_SUITE.erl b/lib/compiler/test/inline_SUITE.erl
index 69c9dcba69..f700059d20 100644
--- a/lib/compiler/test/inline_SUITE.erl
+++ b/lib/compiler/test/inline_SUITE.erl
@@ -42,13 +42,9 @@ groups() ->
 
 init_per_suite(Config) ->
     test_lib:recompile(?MODULE),
-    Pa = "-pa " ++ filename:dirname(code:which(?MODULE)),
-    {ok,Node} = start_node(compiler, Pa),
-    [{testing_node,Node}|Config].
+    Config.
 
-end_per_suite(Config) ->
-    Node = proplists:get_value(testing_node, Config),
-    test_server:stop_node(Node),
+end_per_suite(_Config) ->
     ok.
 
 init_per_group(_GroupName, Config) ->
@@ -89,7 +85,6 @@ attribute(Config) when is_list(Config) ->
 ?comp(maps_inline_test).
 
 try_inline(Mod, Config) ->
-    Node = proplists:get_value(testing_node, Config),
     Src = filename:join(proplists:get_value(data_dir, Config),
 			atom_to_list(Mod)),
     Out = proplists:get_value(priv_dir,Config),
@@ -100,7 +95,7 @@ try_inline(Mod, Config) ->
                                   bin_opt_info,clint,ssalint]),
 
     ct:timetrap({minutes,10}),
-    NormalResult = rpc:call(Node, ?MODULE, load_and_call, [Out,Mod]),
+    NormalResult = load_and_call(Out, Mod),
 
     %% Inlining.
     io:format("Compiling with old inliner: ~s\n", [Src]),
@@ -109,7 +104,7 @@ try_inline(Mod, Config) ->
 
     %% Run inlined code.
     ct:timetrap({minutes,10}),
-    OldInlinedResult = rpc:call(Node, ?MODULE, load_and_call, [Out,Mod]),
+    OldInlinedResult = load_and_call(Out, Mod),
 
     %% Compare results.
     compare(NormalResult, OldInlinedResult),
@@ -122,7 +117,7 @@ try_inline(Mod, Config) ->
 
     %% Run inlined code.
     ct:timetrap({minutes,10}),
-    InlinedResult = rpc:call(Node, ?MODULE, load_and_call, [Out,Mod]),
+    InlinedResult = load_and_call(Out, Mod),
 
     %% Compare results.
     compare(NormalResult, InlinedResult),
@@ -131,6 +126,11 @@ try_inline(Mod, Config) ->
     %% Delete Beam file.
     ok = file:delete(filename:join(Out, atom_to_list(Mod)++code:objfile_extension())),
 
+    %% Delete loaded module.
+    _ = code:purge(Mod),
+    _ = code:delete(Mod),
+    _ = code:purge(Mod),
+
     ok.
 
 compare(Same, Same) -> ok;
@@ -144,12 +144,6 @@ compare([H1|_], [H2|_]) ->
     ct:fail(different);
 compare([], []) -> ok.
 
-start_node(Name, Args) ->
-    case test_server:start_node(Name, slave, [{args,Args}]) of
-	{ok,Node} -> {ok, Node};
-	Error  -> ct:fail(Error)
-    end.
-
 load_and_call(Out, Module) ->
     io:format("Loading...\n",[]),
     code:purge(Module),
diff --git a/lib/compiler/test/inline_SUITE_data/barnes2.erl b/lib/compiler/test/inline_SUITE_data/barnes2.erl
index a986331060..49e9bdfb6b 100644
--- a/lib/compiler/test/inline_SUITE_data/barnes2.erl
+++ b/lib/compiler/test/inline_SUITE_data/barnes2.erl
@@ -6,7 +6,7 @@
 ?MODULE() ->
     Stars = create_scenario(1000, 1.0),
     R = hd(loop(10,1000.0,Stars,0)),
-    Str = lists:flatten(io:lib_format("~s", [R])),
+    Str = lists:flatten(io_lib:format("~p", [R])),
     {R,Str =:= {1.00000,-1.92269e+4,-1.92269e+4,2.86459e-2,2.86459e-2}}.
 
 create_scenario(N, M) ->
diff --git a/lib/compiler/test/test_lib.erl b/lib/compiler/test/test_lib.erl
index 26149e11e6..7fb4751b42 100644
--- a/lib/compiler/test/test_lib.erl
+++ b/lib/compiler/test/test_lib.erl
@@ -104,11 +104,11 @@ is_cloned_mod(Mod) ->
 
 %% Test whether Mod is a cloned module.
 
-is_cloned_mod_1("no_opt_SUITE") -> true;
-is_cloned_mod_1("post_opt_SUITE") -> true;
-is_cloned_mod_1("inline_SUITE") -> true;
-is_cloned_mod_1("21_SUITE") -> true;
-is_cloned_mod_1("no_module_opt_SUITE") -> true;
+is_cloned_mod_1("_no_opt_SUITE") -> true;
+is_cloned_mod_1("_post_opt_SUITE") -> true;
+is_cloned_mod_1("_inline_SUITE") -> true;
+is_cloned_mod_1("_21_SUITE") -> true;
+is_cloned_mod_1("_no_module_opt_SUITE") -> true;
 is_cloned_mod_1([_|T]) -> is_cloned_mod_1(T);
 is_cloned_mod_1([]) -> false.