Ensure included deps transitive from path deps can be loaded, closes #12682

Author: josevalim

lib/mix/lib/mix/dep/converger.ex

@@ -72,8 +72,31 @@ defmodule Mix.Dep.Converger do
   """
   def converge(acc, lock, opts, callback) do
     {deps, acc, lock} = all(acc, lock, opts, callback)
-    if remote = Mix.RemoteConverger.get(), do: remote.post_converge
-    {topological_sort(deps), acc, lock}
+    if remote = Mix.RemoteConverger.get(), do: remote.post_converge()
+
+    deps =
+      for %{app: app, opts: opts} = dep <- topological_sort(deps) do
+        case Keyword.pop(opts, :app_properties) do
+          {nil, _opts} ->
+            dep
+
+          {app_properties, opts} ->
+            case :application.load({:application, app, app_properties}) do
+              :ok ->
+                :ok
+
+              {:error, {:already_loaded, _}} ->
+                :ok
+
+              {:error, error} ->
+                Mix.raise("Could not load application #{inspect(app)}: #{inspect(error)}")
+            end
+
+            %{dep | opts: opts}
+        end
+      end
+
+    {deps, acc, lock}
   end
 
   defp all(acc, lock, opts, callback) do
@@ -205,21 +228,20 @@ defmodule Mix.Dep.Converger do
         all(t, [dep | acc], upper, breadths, optional, rest, lock, state)
 
       :nomatch ->
-        {%{app: app, deps: deps, opts: opts} = dep, app_properties, rest, lock} =
+        {%{app: app, deps: deps, opts: opts} = dep, rest, lock} =
           case state.cache.(dep) do
             {:loaded, cached_dep} ->
-              {cached_dep, nil, rest, lock}
+              {cached_dep, rest, lock}
 
             {:unloaded, dep, children} ->
               {dep, rest, lock} = state.callback.(put_lock(dep, lock), rest, lock)
 
-              Mix.Dep.Loader.with_system_env(dep, fn ->
-                # After we invoke the callback (which may actually check out the
-                # dependency), we load the dependency including its latest info
-                # and children information.
-                {dep, app_properties} = Mix.Dep.Loader.load(dep, children, state.locked?)
-                {dep, app_properties, rest, lock}
-              end)
+              dep =
+                Mix.Dep.Loader.with_system_env(dep, fn ->
+                  Mix.Dep.Loader.load(dep, children, state.locked?)
+                end)
+
+              {dep, rest, lock}
           end
 
         # Something that we previously ruled out as an optional dependency is
@@ -234,24 +256,7 @@ defmodule Mix.Dep.Converger do
           split_non_fulfilled_optional(deps, Enum.map(acc, & &1.app), opts[:from_umbrella])
 
         new_breadths = Enum.map(deps, & &1.app) ++ breadths
-        res = all(deps, acc, breadths, new_breadths, discarded ++ optional, rest, lock, state)
-
-        # After we traverse all of our children, we can load ourselves.
-        # This is important in case of included application.
-        if app_properties do
-          case :application.load({:application, app, app_properties}) do
-            :ok ->
-              :ok
-
-            {:error, {:already_loaded, _}} ->
-              :ok
-
-            {:error, error} ->
-              Mix.raise("Could not start application #{inspect(app)}: #{inspect(error)}")
-          end
-        end
-
-        res
+        all(deps, acc, breadths, new_breadths, discarded ++ optional, rest, lock, state)
     end
   end
 

lib/mix/lib/mix/dep/loader.ex

@@ -383,21 +383,21 @@ defmodule Mix.Dep.Loader do
 
     cond do
       not ok?(dep) ->
-        {dep, nil}
+        dep
 
       recently_fetched?(dep) ->
-        {%{dep | status: :compile}, nil}
+        %{dep | status: :compile}
 
       opts_app == false ->
-        {dep, nil}
+        dep
 
       true ->
         path = if is_binary(opts_app), do: opts_app, else: "ebin/#{app}.app"
         path = Path.expand(path, opts[:build])
 
         case app_status(path, app, req) do
-          {:ok, vsn, app} -> {%{dep | status: {:ok, vsn}}, app}
-          status -> {%{dep | status: status}, nil}
+          {:ok, vsn, app} -> %{dep | status: {:ok, vsn}, opts: [app_properties: app] ++ opts}
+          status -> %{dep | status: status}
         end
     end
   end

lib/mix/lib/mix/dep/umbrella.ex

@@ -59,7 +59,7 @@ defmodule Mix.Dep.Umbrella do
     apps = Enum.map(deps, & &1.app)
 
     Enum.map(deps, fn umbrella_dep ->
-      {umbrella_dep, _} = Mix.Dep.Loader.load(umbrella_dep, nil, false)
+      umbrella_dep = Mix.Dep.Loader.load(umbrella_dep, nil, false)
 
       deps =
         Enum.filter(umbrella_dep.deps, fn dep ->