Ensure compilation of sibling deps do not mark path deps as changed, closes #15158

Author: josevalim

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

@@ -180,8 +180,10 @@ defmodule Mix.Compilers.Elixir do
         Mix.Compilers.Protocol.status(config_mtime > old_config_mtime, opts)
       end
 
-    if stale != [] or stale_modules != %{} or removed != [] or deps_changed? or
-         consolidation_status == :force do
+    consolidate? =
+      consolidation_status == :force or (deps_changed? and consolidation_status != :off)
+
+    if stale != [] or stale_modules != %{} or removed != [] or consolidate? do
       path = opts[:purge_consolidation_path_if_stale]
 
       if is_binary(path) and Code.delete_path(path) do
@@ -266,6 +268,25 @@ defmodule Mix.Compilers.Elixir do
         Code.compiler_options(previous_opts)
       end
     else
+      # Only the dependencies changed but nothing was recompiled,
+      # so we need to update the config_mtime configuration but
+      # keep its original timestamp so recompilation does not cascade.
+      if deps_changed? do
+        write_manifest(
+          manifest,
+          all_modules,
+          all_sources,
+          all_local_exports,
+          old_parents,
+          old_cache_key,
+          old_deps_config,
+          old_project_mtime,
+          config_mtime,
+          old_protocols_and_impls,
+          modified
+        )
+      end
+
       all_warnings = Keyword.get(opts, :all_warnings, true)
       previous_warnings = previous_warnings(sources, all_warnings)
       unless_warnings_as_errors(opts, {:noop, previous_warnings})
@@ -276,7 +297,10 @@ defmodule Mix.Compilers.Elixir do
     # If you change this config, you need to bump @manifest_vsn
     %{
       local: Enum.sort(Enum.map(local_deps, &{&1.app, true})),
-      lock: Enum.sort(Mix.Dep.Lock.read()),
+      lock:
+        Mix.Dep.Lock.read()
+        |> Map.take(Mix.Project.deps_apps())
+        |> Enum.sort(),
       config: Enum.sort(Mix.Tasks.Loadconfig.read_compile()),
       dbg: Application.fetch_env!(:elixir, :dbg_callback)
     }

lib/mix/lib/mix/tasks/compile.app.ex

@@ -201,18 +201,23 @@ defmodule Mix.Tasks.Compile.App do
       :application.unload(app)
       :application.load({:application, app, properties})
 
-      Mix.Project.ensure_structure()
-      File.write!(target, IO.chardata_to_string([contents, ?.]))
-      File.touch!(target, new_mtime)
-
-      # If we just created the .app file, it will have touched
-      # the directory mtime, so we need to reset it.
-      if current_properties == [] do
-        File.touch!(compile_path, new_mtime)
-      end
+      if opts[:force] || Map.new(current_properties) != Map.new(properties) do
+        Mix.Project.ensure_structure()
+        File.write!(target, IO.chardata_to_string([contents, ?.]))
+        File.touch!(target, new_mtime)
+
+        # If we just created the .app file, it will have touched
+        # the directory mtime, so we need to reset it.
+        if current_properties == [] do
+          File.touch!(compile_path, new_mtime)
+        end
 
-      Mix.shell().info("Generated #{app} app")
-      {:ok, []}
+        Mix.shell().info("Generated #{app} app")
+        {:ok, []}
+      else
+        File.touch!(target, new_mtime)
+        {:noop, []}
+      end
     else
       :application.load({:application, app, current_properties})
       {:noop, []}

lib/mix/lib/mix/tasks/test.coverage.ex

@@ -75,16 +75,6 @@ defmodule Mix.Tasks.Test.Coverage do
   coverage techniques. It is up to you and your team to specify how much
   emphasis you want to place on it.
 
-  ## Native coverage
-
-  Erlang/OTP 27+ supports "native coverage", which relies on the JIT compiler
-  to compute coverage, leading to better performance when running a test suite
-  with coverage enabled.
-
-  You can enable it by running:
-
-      ERL_COMPILER_OPTIONS=line_coverage mix test
-
   ## Exporting coverage
 
   This task can be used when you need to group the coverage

lib/mix/test/mix/tasks/compile.app_test.exs

@@ -91,7 +91,7 @@ defmodule Mix.Tasks.Compile.AppTest do
 
       # No-op with untouched unset compile_env
       reset_config.()
-      assert Mix.Tasks.Compile.App.run([]) == {:ok, []}
+      assert Mix.Tasks.Compile.App.run([]) == {:noop, []}
       assert parse_resource_file(:sample)[:compile_env] == [{:app, :key, :error}]
 
       # Recompiles with new compile_env

lib/mix/test/mix/tasks/compile.elixir_test.exs

@@ -523,15 +523,21 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
   test "recompiles files when lock changes" do
     in_fixture("no_mixfile", fn ->
+      Mix.ProjectStack.post_config(
+        deps: [{:git_repo, git: MixTest.Case.fixture_path("git_repo")}]
+      )
+
       Mix.Project.push(MixTest.Case.Sample)
-      Process.put({MixTest.Case.Sample, :application}, extra_applications: [:logger])
 
       File.write!("lib/a.ex", """
       defmodule A do
-        _ = Logger.metadata()
+        _ = GitRepo.__info__(:module)
       end
       """)
 
+      Mix.Task.run("deps.get")
+      Mix.Task.run("loadpaths")
+
       assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
@@ -548,7 +554,7 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
       # Adding to lock recompiles
       File.write!("mix.lock", """
-      %{"logger": :unused}
+      %{"git_repo": :unused}
       """)
 
       assert recompile.() == {:ok, []}
@@ -558,32 +564,32 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
       # Changing lock recompiles
       File.write!("mix.lock", """
-      %{"logger": :another}
+      %{"git_repo": :another}
       """)
 
       assert recompile.() == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
       assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
 
-      # Removing a lock recompiles
+      # Adding to the lock does not recompile
       File.write!("mix.lock", """
-      %{}
+      %{"git_repo": :another, "unknown": :unknown}
       """)
 
       assert recompile.() == {:ok, []}
-      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
-      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
 
-      # Adding an unknown dependency returns :ok but does not recompile
+      # Removing recompiles
       File.write!("mix.lock", """
       %{"unknown": :unknown}
       """)
 
       assert recompile.() == {:ok, []}
-      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
     end)
   end
 
@@ -751,6 +757,67 @@ defmodule Mix.Tasks.Compile.ElixirTest do
     purge([GitRepo, GitRepo.MixProject])
   end
 
+  test "does not recompile files from path dependencies when non-child dependency change" do
+    # Get Git repo first revision
+    [last, first | _] = get_git_repo_revs("git_repo")
+
+    in_fixture("no_mixfile", fn ->
+      File.mkdir_p!("path_dep/lib")
+
+      File.write!("path_dep/mix.exs", """
+      defmodule PathDep.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :path_dep,
+            version: "0.1.0",
+            deps: []
+          ]
+        end
+      end
+      """)
+
+      File.write!("path_dep/lib/path_dep_hello.ex", """
+      defmodule PathDep.Hello do
+      end
+      """)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        PathDep.Hello.__info__(:module)
+      end
+      """)
+
+      File.write!("mix.lock", inspect(%{git_repo: {:git, fixture_path("git_repo"), first, []}}))
+
+      Mix.ProjectStack.post_config(
+        deps: [
+          {:git_repo, "0.1.0", git: fixture_path("git_repo")},
+          {:path_dep, path: "path_dep"}
+        ]
+      )
+
+      Mix.Project.push(MixTest.Case.Sample)
+      Mix.Task.run("deps.get")
+      Mix.Task.run("compile", ["--verbose"])
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+
+      Mix.Task.clear()
+      Mix.State.clear_cache()
+      purge([GitRepo.MixProject, PathDep.MixProject])
+
+      ensure_touched("mix.lock", "_build/dev/lib/sample/.mix/compile.lock")
+      Mix.Task.run("deps.update", ["--all"])
+      assert File.read!("mix.lock") =~ last
+
+      Mix.Task.run("compile", ["--verbose"])
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  after
+    purge([GitRepo, GitRepo.MixProject, PathDep.MixProject])
+  end
+
   test "does not write BEAM files down on failures" do
     in_tmp("blank", fn ->
       Mix.Project.push(MixTest.Case.Sample)