Use read timestamp in both Erlang and Elixir compilers

We fetch the time from before we read files so any future
change to files are still picked up by the compiler. This
timestamp is used when writing beams and the manifest.

Author: José Valim

lib/mix/lib/mix/compilers/elixir.ex

@@ -28,7 +28,12 @@ defmodule Mix.Compilers.Elixir do
   have changed at runtime.
   """
   def compile(manifest, srcs, dest, force, opts) do
+    # We fetch the time from before we read files so any future
+    # change to files are still picked up by the compiler. This
+    # timestamp is used when writing beams and the manifest.
+    timestamp = :calendar.universal_time()
     all = Mix.Utils.extract_files(srcs, [:ex])
+
     {all_modules, all_sources} = parse_manifest(manifest, dest)
     modified = Mix.Utils.last_modified(manifest)
 
@@ -70,10 +75,10 @@ defmodule Mix.Compilers.Elixir do
 
     cond do
       stale != [] ->
-        compile_manifest(manifest, modules, sources, stale, dest, opts)
+        compile_manifest(manifest, modules, sources, stale, dest, timestamp, opts)
         :ok
       removed != [] ->
-        write_manifest(manifest, modules, sources, dest)
+        write_manifest(manifest, modules, sources, dest, timestamp)
         :ok
       true ->
         :noop
@@ -126,7 +131,7 @@ defmodule Mix.Compilers.Elixir do
     end
   end
 
-  defp compile_manifest(manifest, modules, sources, stale, dest, opts) do
+  defp compile_manifest(manifest, modules, sources, stale, dest, timestamp, opts) do
     Mix.Utils.compiling_n(length(stale), :ex)
 
     config = Mix.Project.config()
@@ -156,7 +161,7 @@ defmodule Mix.Compilers.Elixir do
              long_compilation_threshold: long_compilation_threshold,
              dest: dest] ++ extra
       Agent.cast pid, fn {modules, sources} ->
-        write_manifest(manifest, modules, sources, dest)
+        write_manifest(manifest, modules, sources, dest, timestamp)
         {modules, sources}
       end
     after
@@ -381,19 +386,20 @@ defmodule Mix.Compilers.Elixir do
     end)
   end
 
-  defp write_manifest(manifest, [], [], _compile_path) do
+  defp write_manifest(manifest, [], [], _compile_path, _timestamp) do
     File.rm(manifest)
     :ok
   end
 
-  defp write_manifest(manifest, modules, sources, compile_path) do
+  defp write_manifest(manifest, modules, sources, compile_path, timestamp) do
     File.mkdir_p!(Path.dirname(manifest))
 
     modules =
       for module(beam: beam, binary: binary) = module <- modules do
         if binary do
           beam_path = Path.join(compile_path, beam)
           File.write!(beam_path, binary)
+          File.touch!(beam_path, timestamp)
         end
         module(module, binary: nil)
       end
@@ -403,6 +409,7 @@ defmodule Mix.Compilers.Elixir do
       |> :erlang.term_to_binary(compressed: 9)
 
     File.write!(manifest, manifest_data)
+    File.touch!(manifest, timestamp)
 
     # Since Elixir is a dependency itself, we need to touch the lock
     # so the current Elixir version, used to compile the files above,

lib/mix/lib/mix/compilers/erlang.ex

@@ -18,7 +18,7 @@ defmodule Mix.Compilers.Erlang do
       manifest = Path.join Mix.Project.manifest_path, ".compile.lfe"
       dest = Mix.Project.compile_path
 
-      compile manifest, [{"src", dest}], :lfe, :beam, opts[:force], fn
+      compile manifest, [{"src", dest}], :lfe, :beam, opts, fn
         input, output ->
           :lfe_comp.file(to_erl_file(input),
                          [output_dir: Path.dirname(output)])
@@ -42,11 +42,17 @@ defmodule Mix.Compilers.Erlang do
   of error. An error is raised at the end if any of the
   files failed to compile.
   """
-  def compile(manifest, mappings, src_ext, dest_ext, force, callback) do
-    files = for {src, dest} <- mappings do
-              extract_targets(src, src_ext, dest, dest_ext, force)
-            end |> Enum.concat
-    compile(manifest, files, src_ext, callback)
+  def compile(manifest, mappings, src_ext, dest_ext, force, callback) when is_boolean(force) do
+    compile(manifest, mappings, src_ext, dest_ext, [force: force], callback)
+  end
+
+  def compile(manifest, mappings, src_ext, dest_ext, opts, callback) do
+    force = opts[:force]
+    files =
+      for {src, dest} <- mappings do
+        extract_targets(src, src_ext, dest, dest_ext, force)
+      end |> Enum.concat
+    compile(manifest, files, src_ext, opts, callback)
   end
 
   @doc """
@@ -58,14 +64,15 @@ defmodule Mix.Compilers.Erlang do
   must be given. A src/dest pair where destination is `nil` is considered
   to be up to date and won't be (re-)compiled.
   """
-  def compile(manifest, mappings, callback) do
-    compile(manifest, mappings, :erl, callback)
+  def compile(manifest, mappings, opts \\ [], callback) do
+    compile(manifest, mappings, :erl, opts, callback)
   end
 
-  defp compile(manifest, mappings, ext, callback) do
+  defp compile(manifest, mappings, ext, opts, callback) do
     stale = for {:stale, src, dest} <- mappings, do: {src, dest}
 
     # Get the previous entries from the manifest
+    timestamp = :calendar.universal_time()
     entries = read_manifest(manifest)
 
     # Files to remove are the ones in the manifest
@@ -87,15 +94,24 @@ defmodule Mix.Compilers.Erlang do
 
       # Remove manifest entries with no source
       Enum.each(removed, &File.rm/1)
+      verbose = opts[:verbose]
 
       # Compile stale files and print the results
-      results = for {input, output} <- stale do
-        callback.(input, output)
-      end
+      results =
+        for {input, output} <- stale do
+          result = callback.(input, output)
+
+          with {:ok, _} <- result do
+            File.touch!(output, timestamp)
+            verbose && Mix.shell.info "Compiled #{input}"
+          end
+
+          result
+        end
 
       # Write final entries to manifest
       entries = (entries -- removed) ++ Enum.map(stale, &elem(&1, 1))
-      write_manifest(manifest, :lists.usort(entries))
+      write_manifest(manifest, :lists.usort(entries), timestamp)
 
       # Raise if any error, return :ok otherwise
       if :error in results do
@@ -162,8 +178,9 @@ defmodule Mix.Compilers.Erlang do
     end
   end
 
-  defp write_manifest(file, entries) do
+  defp write_manifest(file, entries, timestamp) do
     Path.dirname(file) |> File.mkdir_p!
     File.write!(file, Enum.join(entries, "\n"))
+    File.touch!(file, timestamp)
   end
 end

lib/mix/lib/mix/tasks/compile.erlang.ex

@@ -82,7 +82,7 @@ defmodule Mix.Tasks.Compile.Erlang do
              |> sort_dependencies
              |> Enum.map(&annotate_target(&1, compile_path, opts[:force]))
 
-    Mix.Compilers.Erlang.compile(manifest(), tuples, fn
+    Mix.Compilers.Erlang.compile(manifest(), tuples, opts, fn
       input, _output ->
         # We're purging the module because a previous compiler (e.g. Phoenix)
         # might have already loaded the previous version of it.
@@ -91,15 +91,7 @@ defmodule Mix.Tasks.Compile.Erlang do
         :code.delete(module)
 
         file = to_erl_file(Path.rootname(input, ".erl"))
-        case :compile.file(file, erlc_options) do
-          {:ok, _} = ok ->
-            if opts[:verbose] do
-              Mix.shell.info "Compiled #{input}"
-            end
-            ok
-          :error ->
-            :error
-        end
+        :compile.file(file, erlc_options)
     end)
   end
 
@@ -181,7 +173,7 @@ defmodule Mix.Tasks.Compile.Erlang do
   end
 
   defp annotate_target(erl, compile_path, force) do
-    beam = Path.join(compile_path, "#{erl.module}#{:code.objfile_extension}")
+    beam = Path.join(compile_path, "#{erl.module}.beam")
 
     if force || Mix.Utils.stale?([erl.file | erl.includes], [beam]) do
       {:stale, erl.file, beam}

lib/mix/lib/mix/tasks/compile.leex.ex

@@ -49,19 +49,11 @@ defmodule Mix.Tasks.Compile.Leex do
     mappings     = Enum.zip(source_paths, source_paths)
     options      = project[:leex_options] || []
 
-    Erlang.compile(manifest(), mappings, :xrl, :erl, opts[:force], fn
+    Erlang.compile(manifest(), mappings, :xrl, :erl, opts, fn
       input, output ->
         Erlang.ensure_application!(:parsetools, input)
         options = options ++ @forced_opts ++ [scannerfile: Erlang.to_erl_file(output)]
-        case :leex.file(Erlang.to_erl_file(input), options) do
-          {:ok, _} = ok ->
-            if opts[:verbose] do
-              Mix.shell.info "Compiled #{input}"
-            end
-            ok
-          :error ->
-            :error
-        end
+        :leex.file(Erlang.to_erl_file(input), options)
     end)
   end
 

lib/mix/lib/mix/tasks/compile.yecc.ex

@@ -49,19 +49,11 @@ defmodule Mix.Tasks.Compile.Yecc do
     mappings     = Enum.zip(source_paths, source_paths)
     options      = project[:yecc_options] || []
 
-    Erlang.compile(manifest(), mappings, :yrl, :erl, opts[:force], fn
+    Erlang.compile(manifest(), mappings, :yrl, :erl, opts, fn
       input, output ->
         Erlang.ensure_application!(:parsetools, input)
         options = options ++ @forced_opts ++ [parserfile: Erlang.to_erl_file(output)]
-        case :yecc.file(Erlang.to_erl_file(input), options) do
-          {:ok, _} = ok ->
-            if opts[:verbose] do
-              Mix.shell.info "Compiled #{input}"
-            end
-            ok
-          :error ->
-            :error
-        end
+        :yecc.file(Erlang.to_erl_file(input), options)
     end)
   end