From f2b332186a8cdb90b199b7121881b2ae8a454b8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Valim?= <jose.valim@plataformatec.com.br>
Date: Mon, 3 Jul 2017 14:16:13 +0200
Subject: Make tuple calls opt-in

Tuple calls is the ability to invoke a function on a tuple
as first argument:

    1> Var = dict:new().
    {dict,0,16,16,8,80,48,
          {[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},
          {{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}
    2> Var:size().
    0

This behaviour is considered by most to be undesired and confusing,
especially when it comes to errors. For example, imagine you invoke
"Mod:new()" where a Mod is an atom and you accidentally pass {ok, dict}.
It raises:

    {undef,[{ok,new,[{ok,dict}],[]},...]}

As it attempts to invoke ok:new/1, which is really hard to debug
as there is no call to new/1 on the source code.

Furthemore, this behaviour is implemented at the VM level, which
imposes such semantics on all languages running on BEAM.

Since we cannot remove the behaviour above, this proposal makes the
behaviour opt-in with a compiler flag:

    -compile(tuple_calls).

This means that, if a codebase relies on this functionality, they
can keep compatibility by adding configuring their build tool to
always use the 'tuple_calls' flag or explicitly on each module.

As long as the compile attribute above is listed, the codebase will
work on old and new Erlang versions alike. The only downside of the
current implementation is that modules compiled on OTP 20 that rely
on 'tuple_calls' will have to be recompiled to run with 'tuple_calls'
on OTP 21+.
---
 lib/compiler/test/compile_SUITE.erl | 35 +++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

(limited to 'lib/compiler/test/compile_SUITE.erl')

diff --git a/lib/compiler/test/compile_SUITE.erl b/lib/compiler/test/compile_SUITE.erl
index f647a4030d..aaa2005e73 100644
--- a/lib/compiler/test/compile_SUITE.erl
+++ b/lib/compiler/test/compile_SUITE.erl
@@ -32,7 +32,7 @@
 	 binary/1, makedep/1, cond_and_ifdef/1, listings/1, listings_big/1,
 	 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,
+	 cover/1, env/1, core_pp/1, tuple_calls/1,
 	 core_roundtrip/1, asm/1, optimized_guards/1,
 	 sys_pre_attributes/1, dialyzer/1,
 	 warnings/1, pre_load_check/1, env_compiler_options/1,
@@ -49,7 +49,7 @@ all() ->
     test_lib:recompile(?MODULE),
     [app_test, appup_test, file_1, forms_2, module_mismatch, big_file, outdir,
      binary, makedep, cond_and_ifdef, listings, listings_big,
-     other_output, kernel_listing, encrypted_abstr,
+     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,
      sys_pre_attributes, dialyzer, warnings, pre_load_check,
@@ -781,6 +781,37 @@ extra_chunks(Config) when is_list(Config) ->
     {ok,{extra_chunks,[{"ExCh",<<"Contents">>}]}} =
 	beam_lib:chunks(ExtraChunksBinary, ["ExCh"]).
 
+tuple_calls(Config) when is_list(Config) ->
+    Anno = erl_anno:new(1),
+    Forms = [{attribute,Anno,export,[{size,1},{store,1}]},
+	     {function,Anno,size,1,
+	      [{clause,Anno,[{var,[],mod}],[],
+	       [{call,[],{remote,[],{var,[],mod},{atom,[],size}},[]}]}]},
+	     {function,Anno,store,1,
+	      [{clause,Anno,[{var,[],mod}],[],
+	       [{call,[],{remote,[],{var,[],mod},{atom,[],store}},[{atom,[],key},{atom,[],value}]}]}]}],
+
+    TupleCallsFalse = [{attribute,Anno,module,tuple_calls_false}|Forms],
+    {ok,_,TupleCallsFalseBinary} = compile:forms(TupleCallsFalse, [binary]),
+    code:load_binary(tuple_calls_false, "compile_SUITE.erl", TupleCallsFalseBinary),
+    {'EXIT',{badarg,_}} = (catch tuple_calls_false:store(dict())),
+    {'EXIT',{badarg,_}} = (catch tuple_calls_false:size(dict())),
+    {'EXIT',{badarg,_}} = (catch tuple_calls_false:size(empty_tuple())),
+
+    TupleCallsTrue = [{attribute,Anno,module,tuple_calls_true}|Forms],
+    {ok,_,TupleCallsTrueBinary} = compile:forms(TupleCallsTrue, [binary,tuple_calls]),
+    code:load_binary(tuple_calls_true, "compile_SUITE.erl", TupleCallsTrueBinary),
+    Dict = tuple_calls_true:store(dict()),
+    1 = tuple_calls_true:size(Dict),
+    {'EXIT',{badarg,_}} = (catch tuple_calls_true:size(empty_tuple())),
+
+    ok.
+
+dict() ->
+    dict:new().
+empty_tuple() ->
+    {}.
+
 env(Config) when is_list(Config) ->
     {Simple,Target} = get_files(Config, simple, env),
     {ok,Cwd} = file:get_cwd(),
-- 
cgit v1.2.1