Use unamed tables for module compilation

* We have created a main named table that keeps all module information

* We have reduced the amount of tables by storing internal, docs and
  attributes altogether and using table looks for retriving the relevant
  information

* At this moment, creating a module in Elixir defines three tables,
  one for data, another for functions and another for clauses

Signed-off-by: José Valim <[email protected]>

Author: José Valim

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -33,7 +33,7 @@ defmodule Kernel.LexicalTracker do
   defp to_pid(pid) when is_pid(pid),  do: pid
   defp to_pid(mod) when is_atom(mod) do
     table = :elixir_module.data_table(mod)
-    [{_, val}] = :ets.lookup(table, :__lexical_tracker)
+    [{_, val}] = :ets.lookup(table, {:elixir, :lexical_tracker})
     val
   end
 

lib/elixir/lib/module.ex

@@ -504,19 +504,19 @@ defmodule Module do
   def add_doc(module, line, kind, tuple, signature, doc) when
       kind in [:def, :defmacro, :type, :opaque] and (is_binary(doc) or is_boolean(doc) or doc == nil) do
     assert_not_compiled!(:add_doc, module)
-    table = docs_table_for(module)
+    table = data_table_for(module)
 
     {signature, _} = :lists.mapfoldl fn(x, acc) ->
       {simplify_signature(x, acc), acc + 1}
     end, 1, signature
 
-    case :ets.lookup(table, tuple) do
+    case :ets.lookup(table, {:doc, tuple}) do
       [] ->
-        :ets.insert(table, {tuple, line, kind, signature, doc})
+        :ets.insert(table, {{:doc, tuple}, line, kind, signature, doc})
         :ok
-      [{tuple, line, _old_kind, old_sign, old_doc}] ->
+      [{doc_tuple, line, _old_kind, old_sign, old_doc}] ->
         :ets.insert(table, {
-          tuple,
+          doc_tuple,
           line,
           kind,
           merge_signatures(old_sign, signature, 1),
@@ -612,7 +612,7 @@ defmodule Module do
   """
   def defines?(module, tuple) when is_tuple(tuple) do
     assert_not_compiled!(:defines?, module)
-    table = function_table_for(module)
+    table = defs_table_for(module)
     :ets.lookup(table, tuple) != []
   end
 
@@ -632,7 +632,7 @@ defmodule Module do
   """
   def defines?(module, tuple, kind) do
     assert_not_compiled!(:defines?, module)
-    table = function_table_for(module)
+    table = defs_table_for(module)
     case :ets.lookup(table, tuple) do
       [{_, ^kind, _, _, _, _, _}] -> true
       _ -> false
@@ -652,8 +652,8 @@ defmodule Module do
   """
   def definitions_in(module) do
     assert_not_compiled!(:definitions_in, module)
-    table = function_table_for(module)
-    for {tuple, _, _, _, _, _, _} <- :ets.tab2list(table), do: tuple
+    table = defs_table_for(module)
+    :lists.concat :ets.match(table, {:'$1', :_, :_, :_, :_, :_, :_})
   end
 
   @doc """
@@ -671,8 +671,8 @@ defmodule Module do
   """
   def definitions_in(module, kind) do
     assert_not_compiled!(:definitions_in, module)
-    table = function_table_for(module)
-    for {tuple, stored_kind, _, _, _, _, _} <- :ets.tab2list(table), stored_kind == kind, do: tuple
+    table = defs_table_for(module)
+    :lists.concat :ets.match(table, {:'$1', kind, :_, :_, :_, :_, :_})
   end
 
   @doc """
@@ -698,12 +698,11 @@ defmodule Module do
             []
           end
 
-          old    = get_attribute(module, :__overridable)
+          old    = :elixir_def_overridable.overridable(module)
           merged = :orddict.update(tuple, fn({count, _, _, _}) ->
             {count + 1, clause, neighbours, false}
           end, {1, clause, neighbours, false}, old)
-
-          put_attribute(module, :__overridable, merged)
+          :elixir_def_overridable.overridable(module, merged)
       end
     end
   end
@@ -712,7 +711,7 @@ defmodule Module do
   Returns `true` if `tuple` in `module` is marked as overridable.
   """
   def overridable?(module, tuple) do
-    !!List.keyfind(get_attribute(module, :__overridable), tuple, 0)
+    !!List.keyfind(:elixir_def_overridable.overridable(module), tuple, 0)
   end
 
   @doc """
@@ -731,7 +730,7 @@ defmodule Module do
     assert_not_compiled!(:put_attribute, module)
     table = data_table_for(module)
     value = normalize_attribute(key, value)
-    acc   = :ets.lookup_element(table, :__acc_attributes, 2)
+    acc   = :ets.lookup_element(table, {:elixir, :acc_attributes}, 2)
 
     new =
       if :lists.member(key, acc) do
@@ -832,13 +831,13 @@ defmodule Module do
     table = data_table_for(module)
 
     if Keyword.get(opts, :persist) do
-      old = :ets.lookup_element(table, :__persisted_attributes, 2)
-      :ets.insert(table, {:__persisted_attributes,  [new|old]})
+      old = :ets.lookup_element(table, {:elixir, :persisted_attributes}, 2)
+      :ets.insert(table, {{:elixir, :persisted_attributes}, [new|old]})
     end
 
     if Keyword.get(opts, :accumulate) do
-      old = :ets.lookup_element(table, :__acc_attributes, 2)
-      :ets.insert(table, {:__acc_attributes,  [new|old]})
+      old = :ets.lookup_element(table, {:elixir, :acc_attributes}, 2)
+      :ets.insert(table, {{:elixir, :acc_attributes}, [new|old]})
     end
   end
 
@@ -901,7 +900,7 @@ defmodule Module do
     case :ets.lookup(table, key) do
       [{^key, val}] -> val
       [] ->
-        acc = :ets.lookup_element(table, :__acc_attributes, 2)
+        acc = :ets.lookup_element(table, {:elixir, :acc_attributes}, 2)
 
         cond do
           :lists.member(key, acc) ->
@@ -956,15 +955,11 @@ defmodule Module do
   end
 
   defp data_table_for(module) do
-    module
-  end
-
-  defp function_table_for(module) do
-    :elixir_def.table(module)
+    :elixir_module.data_table(module)
   end
 
-  defp docs_table_for(module) do
-    :elixir_module.docs_table(module)
+  defp defs_table_for(module) do
+    :elixir_module.defs_table(module)
   end
 
   defp assert_not_compiled!(fun, module) do

lib/elixir/lib/module/locals_tracker.ex

@@ -83,7 +83,7 @@ defmodule Module.LocalsTracker do
   defp to_pid(pid) when is_pid(pid),  do: pid
   defp to_pid(mod) when is_atom(mod) do
     table = :elixir_module.data_table(mod)
-    [{_, val}] = :ets.lookup(table, :__locals_tracker)
+    [{_, val}] = :ets.lookup(table, {:elixir, :locals_tracker})
     val
   end
 

lib/elixir/src/elixir_def.erl

@@ -1,49 +1,35 @@
 % Holds the logic responsible for function definitions (def(p) and defmacro(p)).
 -module(elixir_def).
--export([table/1, clauses_table/1, setup/1,
-  cleanup/1, reset_last/1, lookup_definition/2,
+-export([setup/1, reset_last/1, lookup_definition/2,
   delete_definition/2, store_definition/6, unwrap_definitions/2,
-  store_each/8, format_error/1]).
+  store_each/7, format_error/1]).
 -include("elixir.hrl").
 
--define(attr, '__def_table').
--define(clauses_attr, '__clauses_table').
+-define(last_def, {elixir, last_def}).
+-define(attr, {elixir, def_table}).
+-define(clauses_attr, {elixir, clauses_table}).
 
 %% Table management functions. Called internally.
 
-table(Module) ->
-  ets:lookup_element(Module, ?attr, 2).
-
-clauses_table(Module) ->
-  ets:lookup_element(Module, ?clauses_attr, 2).
-
 setup(Module) ->
-  ets:insert(Module, {?attr, ets:new(Module, [set, public])}),
-  ets:insert(Module, {?clauses_attr, ets:new(Module, [bag, public])}),
   reset_last(Module),
   ok.
 
-cleanup(Module) ->
-  ets:delete(table(Module)),
-  ets:delete(clauses_table(Module)).
-
-%% Reset the last item. Useful when evaling code.
 reset_last(Module) ->
-  ets:insert(table(Module), {last, []}).
+  ets:insert(elixir_module:data_table(Module), {?last_def, []}).
 
-%% Looks up a definition from the database.
 lookup_definition(Module, Tuple) ->
-  case ets:lookup(table(Module), Tuple) of
+  case ets:lookup(elixir_module:defs_table(Module), Tuple) of
     [Result] ->
-      CTable = clauses_table(Module),
+      CTable = elixir_module:clas_table(Module),
       {Result, [Clause || {_, Clause} <- ets:lookup(CTable, Tuple)]};
     _ ->
       false
   end.
 
 delete_definition(Module, Tuple) ->
-  ets:delete(table(Module), Tuple),
-  ets:delete(clauses_table(Module), Tuple).
+  ets:delete(elixir_module:defs_table(Module), Tuple),
+  ets:delete(elixir_module:clas_table(Module), Tuple).
 
 % Invoked by the wrap definition with the function abstract tree.
 % Each function is then added to the function table.
@@ -98,16 +84,12 @@ store_definition(Line, Kind, CheckClauses, Name, Args, Guards, Body, KeepLocatio
   DefaultsLength = length(Defaults),
   elixir_locals:record_defaults(Tuple, Kind, Module, DefaultsLength),
 
-  File   = ?m(E, file),
-  Table  = table(Module),
-  CTable = clauses_table(Module),
-
+  File = ?m(E, file),
   compile_super(Module, Super, E),
-  check_previous_defaults(Table, Line, Name, Arity, Kind, DefaultsLength, E),
+  check_previous_defaults(Line, Module, Name, Arity, Kind, DefaultsLength, E),
 
-  store_each(CheckClauses, Kind, File, Location,
-    Table, CTable, DefaultsLength, Function),
-  [store_each(false, Kind, File, Location, Table, CTable, 0,
+  store_each(CheckClauses, Kind, File, Location, Module, DefaultsLength, Function),
+  [store_each(false, Kind, File, Location, Module, 0,
     default_function_for(Kind, Name, Default)) || Default <- Defaults],
 
   make_struct_available(Kind, Module, Name, Args),
@@ -166,7 +148,7 @@ normalize_location(File) ->
 %% Compile super
 
 compile_super(Module, true, #{function := Function}) ->
-  elixir_def_overridable:store(Module, Function, true);
+  elixir_def_overridable:super(Module, Function);
 compile_super(_Module, _, _E) -> ok.
 
 %% Translate the given call and expression given
@@ -229,9 +211,8 @@ is_macro(_)         -> false.
 % It returns a list of all functions to be exported, plus the macros,
 % and the body of all functions.
 unwrap_definitions(File, Module) ->
-  Table  = table(Module),
-  CTable = clauses_table(Module),
-  ets:delete(Table, last),
+  Table  = elixir_module:defs_table(Module),
+  CTable = elixir_module:clas_table(Module),
 
   {All, Private} = unwrap_definition(ets:tab2list(Table), File, Module, CTable, [], []),
   Unreachable = elixir_locals:warn_unused_local(File, Module, Private),
@@ -327,26 +308,33 @@ warn_bodyless_function(Line, File, _Module, Kind, Tuple) ->
 %% This function also checks and emit warnings in case
 %% the kind, of the visibility of the function changes.
 
-store_each(Check, Kind, File, Location, Table, CTable, Defaults, {function, Line, Name, Arity, Clauses}) ->
-  Tuple = {Name, Arity},
+store_each(Check, Kind, File, Location, Module, Defaults, {function, Line, Name, Arity, Clauses}) ->
+  Data = elixir_module:data_table(Module),
+  Defs = elixir_module:defs_table(Module),
+  Clas = elixir_module:clas_table(Module),
+
+  Tuple   = {Name, Arity},
   HasBody = Clauses =/= [],
-  case ets:lookup(Table, Tuple) of
-    [{Tuple, StoredKind, StoredLine, StoredFile, StoredCheck, StoredLocation, {StoredDefaults, LastHasBody, LastDefaults}}] ->
+
+  case ets:lookup(Defs, Tuple) of
+    [{Tuple, StoredKind, StoredLine, StoredFile, StoredCheck,
+        StoredLocation, {StoredDefaults, LastHasBody, LastDefaults}}] ->
       FinalLine = StoredLine,
       FinalLocation = StoredLocation,
       FinalDefaults = {max(Defaults, StoredDefaults), HasBody, Defaults},
       check_valid_kind(Line, File, Name, Arity, Kind, StoredKind),
       (Check and StoredCheck) andalso
-        check_valid_clause(Line, File, Name, Arity, Kind, Table, StoredLine, StoredFile),
+        check_valid_clause(Line, File, Name, Arity, Kind, Data, StoredLine, StoredFile),
       check_valid_defaults(Line, File, Name, Arity, Kind, Defaults, LastDefaults, LastHasBody);
     [] ->
       FinalLine = Line,
       FinalLocation = Location,
       FinalDefaults = {Defaults, HasBody, Defaults}
   end,
-  Check andalso ets:insert(Table, {last, {Name, Arity}}),
-  ets:insert(CTable, [{Tuple, Clause} || Clause <- Clauses ]),
-  ets:insert(Table, {Tuple, Kind, FinalLine, File, Check, FinalLocation, FinalDefaults}).
+
+  Check andalso ets:insert(Data, {?last_def, {Name, Arity}}),
+  ets:insert(Clas, [{Tuple, Clause} || Clause <- Clauses]),
+  ets:insert(Defs, {Tuple, Kind, FinalLine, File, Check, FinalLocation, FinalDefaults}).
 
 %% Validations
 
@@ -355,8 +343,8 @@ check_valid_kind(Line, File, Name, Arity, Kind, StoredKind) ->
   elixir_errors:form_error([{line, Line}], File, ?MODULE,
     {changed_kind, {Name, Arity, StoredKind, Kind}}).
 
-check_valid_clause(Line, File, Name, Arity, Kind, Table, StoredLine, StoredFile) ->
-  case ets:lookup_element(Table, last, 2) of
+check_valid_clause(Line, File, Name, Arity, Kind, Data, StoredLine, StoredFile) ->
+  case ets:lookup_element(Data, ?last_def, 2) of
     {Name,Arity} -> [];
     [] -> [];
     _ ->
@@ -379,8 +367,8 @@ check_valid_defaults(Line, File, Name, Arity, Kind, _, _, _) ->
   elixir_errors:form_error([{line, Line}], File, ?MODULE,
     {clauses_with_defaults, {Kind, Name, Arity}}).
 
-check_previous_defaults(Table, Line, Name, Arity, Kind, Defaults, E) ->
-  Matches = ets:match(Table, {{Name, '$2'}, '$1', '_', '_', '_', '_', {'$3', '_', '_'}}),
+check_previous_defaults(Line, Module, Name, Arity, Kind, Defaults, E) ->
+  Matches = ets:match(elixir_module:defs_table(Module), {{Name, '$2'}, '$1', '_', '_', '_', '_', {'$3', '_', '_'}}),
   [ begin
       elixir_errors:form_error([{line, Line}], ?m(E, file), ?MODULE,
         {defs_with_defaults, Name, {Kind, Arity}, {K, A}})

lib/elixir/src/elixir_def_overridable.erl

@@ -1,14 +1,18 @@
 % Holds the logic responsible for defining overridable functions and handling super.
 -module(elixir_def_overridable).
--export([store_pending/1, ensure_defined/4,
-  name/2, store/3, format_error/1]).
+-export([setup/1, overridable/1, overridable/2, name/2, super/2, store_pending/1,
+         ensure_defined/4, format_error/1]).
 -include("elixir.hrl").
+-define(attr, {elixir, overridable}).
+
+setup(Module) ->
+  overridable(Module, []).
 
 overridable(Module) ->
-  ets:lookup_element(elixir_module:data_table(Module), '__overridable', 2).
+  ets:lookup_element(elixir_module:data_table(Module), ?attr, 2).
 
 overridable(Module, Value) ->
-  ets:insert(elixir_module:data_table(Module), {'__overridable', Value}).
+  ets:insert(elixir_module:data_table(Module), {?attr, Value}).
 
 %% Check if an overridable function is defined.
 
@@ -51,11 +55,11 @@ store(Module, Function, GenerateName) ->
       end,
 
       Def = {function, Line, FinalName, Arity, Clauses},
-      elixir_def:store_each(false, FinalKind, File, Location,
-        elixir_def:table(Module), elixir_def:clauses_table(Module), Defaults, Def)
+      elixir_def:store_each(false, FinalKind, File, Location, Module, Defaults, Def)
   end.
 
-%% Store pending declarations that were not manually made concrete.
+super(Module, Function) ->
+  store(Module, Function, true).
 
 store_pending(Module) ->
   _ = [store(Module, X, false) || {X, {_, _, _, false}} <- overridable(Module),
@@ -73,4 +77,4 @@ format_error({no_super, Module, {Name, Arity}}) ->
 format_fa({Name, Arity}) ->
   A = atom_to_binary(Name, utf8),
   B = integer_to_binary(Arity),
-  << A/binary, $/, B/binary >>.
+  <<A/binary, $/, B/binary>>.