Disable tail call optimization on file root entries

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -4903,17 +4903,6 @@ defmodule Kernel do
           {expanded, nil}
       end
 
-    # We do this so that the block is not tail-call optimized and stacktraces
-    # are not messed up. Basically, we just insert something between the return
-    # value of the block and what is returned by defmodule. Using just ":ok" or
-    # similar doesn't work because it's likely optimized away by the compiler.
-    block =
-      quote do
-        result = unquote(block)
-        :elixir_utils.noop()
-        result
-      end
-
     escaped =
       case env do
         %{function: nil, lexical_tracker: pid} when is_pid(pid) ->

lib/elixir/src/elixir_compiler.erl

@@ -16,7 +16,7 @@ quoted(Forms, File, Callback) ->
 
     elixir_lexical:run(
       Env,
-      fun (LexicalEnv) -> eval_or_compile(Forms, [], LexicalEnv) end,
+      fun (LexicalEnv) -> maybe_fast_compile(Forms, [], LexicalEnv) end,
       fun (#{lexical_tracker := Pid}) -> Callback(File, Pid) end
     ),
 
@@ -32,16 +32,17 @@ file(File, Callback) ->
 %% Evaluates the given code through the Erlang compiler.
 %% It may end-up evaluating the code if it is deemed a
 %% more efficient strategy depending on the code snippet.
-eval_or_compile(Forms, Args, E) ->
+maybe_fast_compile(Forms, Args, E) ->
   case (?key(E, module) == nil) andalso allows_fast_compilation(Forms) andalso
         (not elixir_config:is_bootstrap()) of
     true  -> fast_compile(Forms, E);
     false -> compile(Forms, Args, E)
   end,
   ok.
 
-compile(Quoted, ArgsList, E) ->
-  {Expanded, SE, EE} = elixir_expand:expand(Quoted, elixir_env:env_to_ex(E), E),
+compile(Quoted, ArgsList, #{line := Line} = E) ->
+  Block = no_tail_optimize([{line, Line}], Quoted),
+  {Expanded, SE, EE} = elixir_expand:expand(Block, elixir_env:env_to_ex(E), E),
   elixir_env:check_unused_vars(SE, EE),
 
   {Module, Fun, Purgeable} =
@@ -55,7 +56,7 @@ spawned_compile(ExExprs, #{line := Line, file := File} = E) ->
   {ErlExprs, _} = elixir_erl_pass:translate(ExExprs, erl_anno:new(Line), S),
 
   Module = retrieve_compiler_module(),
-  Fun  = code_fun(?key(E, module)),
+  Fun = code_fun(?key(E, module)),
   Forms = code_mod(Fun, ErlExprs, Line, File, Module, Vars),
 
   {Module, Binary} = elixir_erl_compiler:noenv_forms(Forms, File, [nowarn_nomatch, no_bool_opt, no_ssa_opt]),
@@ -106,15 +107,9 @@ allows_fast_compilation(_) ->
 
 fast_compile({'__block__', _, Exprs}, E) ->
   lists:foldl(fun(Expr, _) -> fast_compile(Expr, E) end, nil, Exprs);
-fast_compile({defmodule, Meta, [Mod, [{do, TailBlock}]]}, NoLineE) ->
+fast_compile({defmodule, Meta, [Mod, [{do, Block}]]}, NoLineE) ->
   E = NoLineE#{line := ?line(Meta)},
 
-  Block = {'__block__', Meta, [
-    {'=', Meta, [{result, Meta, ?MODULE}, TailBlock]},
-    {{'.', Meta, [elixir_utils, noop]}, Meta, []},
-    {result, Meta, ?MODULE}
-  ]},
-
   Expanded = case Mod of
     {'__aliases__', _, _} ->
       case elixir_aliases:expand_or_concat(Mod, E) of
@@ -129,6 +124,13 @@ fast_compile({defmodule, Meta, [Mod, [{do, TailBlock}]]}, NoLineE) ->
   ContextModules = [Expanded | ?key(E, context_modules)],
   elixir_module:compile(Expanded, Block, [], false, E#{context_modules := ContextModules}).
 
+no_tail_optimize(Meta, Block) ->
+  {'__block__', Meta, [
+    {'=', Meta, [{result, Meta, ?MODULE}, Block]},
+    {{'.', Meta, [elixir_utils, noop]}, Meta, []},
+    {result, Meta, ?MODULE}
+  ]}.
+
 %% Bootstrapper
 
 bootstrap() ->

lib/elixir/test/elixir/code_test.exs

@@ -347,7 +347,12 @@ defmodule CodeTest do
       assert env.versioned_vars == %{}
 
       assert_receive {:trace, {:on_module, _, _}, %{module: CodeTest.TracingPruning} = trace_env}
-      assert trace_env.versioned_vars == %{{:result, Kernel} => 5, {:x, nil} => 1, {:y, nil} => 4}
+
+      assert trace_env.versioned_vars == %{
+               {:result, :elixir_compiler} => 5,
+               {:x, nil} => 1,
+               {:y, nil} => 4
+             }
     end
 
     test "with defguard" do
@@ -496,6 +501,14 @@ defmodule CodeTest do
       :code.purge(CompileCrossSample)
       :code.delete(CompileCrossSample)
     end
+
+    test "disables tail call optimization at the root" do
+      try do
+        Code.compile_string("List.flatten(123)")
+      rescue
+        _ -> assert Enum.any?(__STACKTRACE__, &match?({_, :__FILE__, 1, _}, &1))
+      end
+    end
   end
 
   test "format_string/2 returns empty iodata for empty string" do