Move locals to types

Author: josevalim

lib/elixir/lib/module.ex

@@ -1415,15 +1415,7 @@ defmodule Module do
   def delete_definition(module, {name, arity})
       when is_atom(module) and is_atom(name) and is_integer(arity) do
     assert_not_readonly!(__ENV__.function, module)
-
-    case :elixir_def.take_definition(module, {name, arity}) do
-      false ->
-        false
-
-      _ ->
-        :elixir_locals.yank({name, arity}, module)
-        true
-    end
+    :elixir_def.take_definition(module, {name, arity}) != false
   end
 
   @doc """
@@ -1452,8 +1444,7 @@ defmodule Module do
                     "overridable because it was not defined"
 
           clause ->
-            neighbours = :elixir_locals.yank(tuple, module)
-            :elixir_overridable.record_overridable(module, tuple, clause, neighbours)
+            :elixir_overridable.record_overridable(module, tuple, clause)
         end
 
       other ->

lib/elixir/lib/module/types.ex

@@ -9,17 +9,34 @@ defmodule Module.Types do
 
   @doc false
   def infer(module, file, defs, private, used, env) do
-    finder = &List.keyfind(defs, &1, 0)
-    handler = &local_handler(&1, &2, &3, finder)
+    finder = &:lists.keyfind(&1, 1, defs)
+
+    handler = fn meta, fun_arity, stack, context ->
+      case local_handler(meta, fun_arity, stack, context, finder) do
+        false ->
+          undefined_function!(:undefined_function, meta, fun_arity, stack, env)
+          false
+
+        {kind, _, _} = triplet ->
+          if (kind == :defmacro or kind == :defmacrop) and not Keyword.has_key?(meta, :super) do
+            undefined_function!(:incorrect_dispatch, meta, fun_arity, stack, env)
+            false
+          else
+            triplet
+          end
+      end
+    end
+
     stack = stack(:infer, file, module, {:__info__, 1}, :all, env, handler)
     context = context(%{})
 
     {types, %{local_sigs: local_sigs}} =
-      for {fun_arity, kind, _meta, _clauses} = def <- defs,
+      for {fun_arity, kind, meta, _clauses} = def <- defs,
           kind == :def or kind == :defmacro,
           reduce: {[], context} do
         {types, context} ->
-          {_kind, inferred, context} = local_handler(fun_arity, stack, context, fn _ -> def end)
+          {_kind, inferred, context} =
+            local_handler(meta, fun_arity, stack, context, fn _ -> def end)
 
           if kind == :def and fun_arity not in @no_infer do
             {[{fun_arity, inferred} | types], context}
@@ -37,6 +54,12 @@ defmodule Module.Types do
     {Map.new(types), unreachable}
   end
 
+  defp undefined_function!(reason, meta, {fun, arity}, stack, env) do
+    env = %{env | function: stack.function, file: stack.file}
+    tuple = {reason, {fun, arity}, stack.module}
+    :elixir_errors.module_error(Helpers.with_span(meta, fun), env, __MODULE__, tuple)
+  end
+
   defp warn_unused_def({_fun_arity, _kind, false, _}, _reachable, _used, _env) do
     :ok
   end
@@ -80,14 +103,16 @@ defmodule Module.Types do
 
   @doc false
   def warnings(module, file, defs, no_warn_undefined, cache) do
-    finder = &List.keyfind(defs, &1, 0)
-    handler = &local_handler(&1, &2, &3, finder)
+    finder = &:lists.keyfind(&1, 1, defs)
+    handler = &local_handler(&1, &2, &3, &4, finder)
     stack = stack(:dynamic, file, module, {:__info__, 1}, no_warn_undefined, cache, handler)
     context = context(%{})
 
     context =
-      Enum.reduce(defs, context, fn {fun_arity, _kind, _meta, _clauses} = def, context ->
-        {_kind, _inferred, context} = local_handler(fun_arity, stack, context, fn _ -> def end)
+      Enum.reduce(defs, context, fn {fun_arity, _kind, meta, _clauses} = def, context ->
+        {_kind, _inferred, context} =
+          local_handler(meta, fun_arity, stack, context, fn _ -> def end)
+
         context
       end)
 
@@ -112,7 +137,7 @@ defmodule Module.Types do
     end
   end
 
-  defp local_handler(fun_arity, stack, context, finder) do
+  defp local_handler(_meta, fun_arity, stack, context, finder) do
     case context.local_sigs do
       %{^fun_arity => {kind, inferred, _mapping}} ->
         {kind, inferred, context}
@@ -121,47 +146,58 @@ defmodule Module.Types do
         {kind, :none, context}
 
       local_sigs ->
-        {{fun, arity}, kind, meta, clauses} =
-          finder.(fun_arity) || raise "could not find #{inspect(fun_arity)}"
-
-        expected = List.duplicate(Descr.dynamic(), arity)
-        stack = stack |> fresh_stack(fun_arity) |> with_file_meta(meta)
-        context = put_in(context.local_sigs, Map.put(local_sigs, fun_arity, kind))
-
-        {_, _, mapping, clauses_types, clauses_context} =
-          Enum.reduce(clauses, {0, 0, [], [], context}, fn
-            {meta, args, guards, body}, {index, total, mapping, inferred, context} ->
-              context = fresh_context(context)
-
-              try do
-                {args_types, context} =
-                  Pattern.of_head(args, guards, expected, :default, meta, stack, context)
-
-                {return_type, context} =
-                  Expr.of_expr(body, stack, context)
-
-                {type_index, inferred} =
-                  add_inferred(inferred, args_types, return_type, total - 1, [])
-
-                if type_index == -1 do
-                  {index + 1, total + 1, [{index, total} | mapping], inferred, context}
-                else
-                  {index + 1, total, [{index, type_index} | mapping], inferred, context}
-                end
-              rescue
-                e ->
-                  internal_error!(e, __STACKTRACE__, kind, meta, fun, args, guards, body, stack)
-              end
-          end)
-
-        inferred = {:infer, Enum.reverse(clauses_types)}
-        triplet = {kind, inferred, mapping}
-        context = restore_context(context, clauses_context)
-        context = update_in(context.local_sigs, &Map.put(&1, fun_arity, triplet))
-        {kind, inferred, context}
+        case finder.(fun_arity) do
+          {fun_arity, kind, meta, clauses} ->
+            context = put_in(context.local_sigs, Map.put(local_sigs, fun_arity, kind))
+
+            {inferred, mapping, context} =
+              local_handler(fun_arity, kind, meta, clauses, stack, context)
+
+            context =
+              update_in(context.local_sigs, &Map.put(&1, fun_arity, {kind, inferred, mapping}))
+
+            {kind, inferred, context}
+
+          false ->
+            false
+        end
     end
   end
 
+  defp local_handler({fun, arity} = fun_arity, kind, meta, clauses, stack, context) do
+    expected = List.duplicate(Descr.dynamic(), arity)
+    stack = stack |> fresh_stack(fun_arity) |> with_file_meta(meta)
+
+    {_, _, mapping, clauses_types, clauses_context} =
+      Enum.reduce(clauses, {0, 0, [], [], context}, fn
+        {meta, args, guards, body}, {index, total, mapping, inferred, context} ->
+          context = fresh_context(context)
+
+          try do
+            {args_types, context} =
+              Pattern.of_head(args, guards, expected, :default, meta, stack, context)
+
+            {return_type, context} =
+              Expr.of_expr(body, stack, context)
+
+            {type_index, inferred} =
+              add_inferred(inferred, args_types, return_type, total - 1, [])
+
+            if type_index == -1 do
+              {index + 1, total + 1, [{index, total} | mapping], inferred, context}
+            else
+              {index + 1, total, [{index, type_index} | mapping], inferred, context}
+            end
+          rescue
+            e ->
+              internal_error!(e, __STACKTRACE__, kind, meta, fun, args, guards, body, stack)
+          end
+      end)
+
+    inferred = {:infer, Enum.reverse(clauses_types)}
+    {inferred, mapping, restore_context(context, clauses_context)}
+  end
+
   # We check for term equality of types as an optimization
   # to reduce the amount of check we do at runtime.
   defp add_inferred([{args, existing_return} | tail], args, return, index, acc),
@@ -306,4 +342,16 @@ defmodule Module.Types do
 
   def format_error({:unused_def, {name, arity}, :defmacrop}),
     do: "macro #{name}/#{arity} is unused"
+
+  def format_error({:undefined_function, {f, a}, _})
+      when {f, a} in [__info__: 1, behaviour_info: 1, module_info: 1, module_info: 0],
+      do:
+        "undefined function #{f}/#{a} (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.#{f}/#{a})"
+
+  def format_error({:undefined_function, {f, a}, module}),
+    do:
+      "undefined function #{f}/#{a} (expected #{inspect(module)} to define such a function or for it to be imported, but none are available)"
+
+  def format_error({:incorrect_dispatch, {f, a}, _module}),
+    do: "cannot invoke macro #{f}/#{a} before its definition"
 end

lib/elixir/lib/module/types/apply.ex

@@ -508,30 +508,35 @@ defmodule Module.Types.Apply do
   @doc """
   Deal with local functions.
   """
-  def local(fun, args_types, expr, stack, context) do
+  def local(fun, args_types, {_, meta, _} = expr, stack, context) do
     fun_arity = {fun, length(args_types)}
-    {kind, info, context} = stack.local_handler.(fun_arity, stack, context)
 
-    case apply_signature(info, args_types, stack) do
-      {:ok, indexes, type} ->
-        context =
-          if stack != :infer and kind == :defp do
-            update_in(context.local_used[fun_arity], fn current ->
-              if info == :none do
-                []
+    case stack.local_handler.(meta, fun_arity, stack, context) do
+      false ->
+        {dynamic(), context}
+
+      {kind, info, context} ->
+        case apply_signature(info, args_types, stack) do
+          {:ok, indexes, type} ->
+            context =
+              if stack != :infer and kind == :defp do
+                update_in(context.local_used[fun_arity], fn current ->
+                  if info == :none do
+                    []
+                  else
+                    (current || used_from_clauses(info)) -- indexes
+                  end
+                end)
               else
-                (current || used_from_clauses(info)) -- indexes
+                context
               end
-            end)
-          else
-            context
-          end
 
-        {type, context}
+            {type, context}
 
-      {:error, domain, clauses} ->
-        error = {:badlocal, expr, args_types, domain, clauses, context}
-        {error_type(), error(error, elem(expr, 1), stack, context)}
+          {:error, domain, clauses} ->
+            error = {:badlocal, expr, args_types, domain, clauses, context}
+            {error_type(), error(error, with_span(meta, fun), stack, context)}
+        end
     end
   end
 
@@ -544,15 +549,20 @@ defmodule Module.Types.Apply do
   @doc """
   Deal with local captures.
   """
-  def local_capture(fun, arity, _meta, stack, context) do
+  def local_capture(fun, arity, meta, stack, context) do
     fun_arity = {fun, arity}
-    {kind, _info, context} = stack.local_handler.(fun_arity, stack, context)
 
-    if stack != :infer and kind == :defp do
-      # Mark all clauses as used, as the function is being exported.
-      {fun(), put_in(context.local_used[fun_arity], [])}
-    else
-      {fun(), context}
+    case stack.local_handler.(meta, fun_arity, stack, context) do
+      false ->
+        {fun(), context}
+
+      {kind, _info, context} ->
+        if stack != :infer and kind == :defp do
+          # Mark all clauses as used, as the function is being exported.
+          {fun(), put_in(context.local_used[fun_arity], [])}
+        else
+          {fun(), context}
+        end
     end
   end
 

lib/elixir/lib/module/types/helpers.ex

@@ -38,6 +38,13 @@ defmodule Module.Types.Helpers do
   def get_meta({_, meta, _}), do: meta
   def get_meta(_other), do: []
 
+  @doc """
+  Attaches span information.
+  """
+  def with_span(meta, name) do
+    :elixir_env.calculate_span(meta, name)
+  end
+
   ## Warnings
 
   @doc """

lib/elixir/src/elixir_def.erl

@@ -217,7 +217,6 @@ store_definition(Meta, Kind, CheckClauses, Name, Arity, DefaultsArgs, Guards, Bo
              Clause <- def_to_clauses(Kind, Meta, Args, Guards, Body, E)],
 
   DefaultsLength = length(Defaults),
-  elixir_locals:record_defaults(Tuple, Kind, Module, DefaultsLength, Meta),
   check_previous_defaults(Meta, Module, Name, Arity, Kind, DefaultsLength, E),
 
   store_definition(CheckClauses, Kind, Meta, Name, Arity, File,

lib/elixir/src/elixir_dispatch.erl

@@ -74,7 +74,6 @@ import_function(Meta, Name, Arity, E) ->
                 elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E) of
             false ->
               elixir_env:trace({local_function, Meta, Name, Arity}, E),
-              elixir_locals:record_local(Tuple, ?key(E, module), ?key(E, function), Meta, false),
               {local, Name, Arity};
             _ ->
               false
@@ -183,10 +182,7 @@ expand_import(Meta, Name, Arity, E, Extra, AllowLocals, Trace) ->
 
         %% Dispatch to the local.
         {_, {_Kind, Fun}} ->
-          Trace andalso begin
-            elixir_env:trace({local_macro, Meta, Name, Arity}, E),
-            elixir_locals:record_local(Tuple, Module, ?key(E, function), Meta, true)
-          end,
+          Trace andalso elixir_env:trace({local_macro, Meta, Name, Arity}, E),
           {macro, Module, expander_macro_fun(Meta, Fun, Module, Name, E)}
       end
   end.

lib/elixir/src/elixir_expand.erl

@@ -900,8 +900,7 @@ expand_local(Meta, Name, Args, S, #{module := Module, function := Function, cont
 
     nil ->
       Arity = length(Args),
-      elixir_env:trace({local_function, Meta, Name, Arity}, E),
-      elixir_locals:record_local({Name, Arity}, Module, Function, Meta, false)
+      elixir_env:trace({local_function, Meta, Name, Arity}, E)
   end,
 
   {EArgs, SA, EA} = expand_args(Args, S, E),