         compiled? and fetchable?
       end)
 
-    if true in compiled, do: Mix.Dep.Lock.touch_manifest, else: :ok
+    if true in compiled, do: Mix.Dep.Lock.touch_manifest(), else: :ok
   end
 
   defp maybe_clean(app, opts) do
     if Keyword.get(opts, :force, false) do
-      File.rm_rf! Path.join [Mix.Project.build_path, "lib", Atom.to_string(app)]
+      File.rm_rf!(Path.join([Mix.Project.build_path(), "lib", Atom.to_string(app)]))
     end
   end
 

  `b` is included in the compilation step, pass `--include-children`.
  """

  import Mix.Dep, only: [loaded: 1, available?: 1, loaded_by_name: 2,
                         make?: 1, mix?: 1]

  @switches [include_children: :boolean, force: :boolean]

  @spec run(OptionParser.argv) :: :ok
  def run(args) do
    unless "--no-archives-check" in args do
      Mix.Task.run "archive.check", args
    end

    Mix.Project.get!

    case OptionParser.parse(args, switches: @switches) do
      {opts, [], _} ->
        # Because this command may be invoked explicitly with
        # deps.compile, we simply try to compile any available
        # dependency.
        compile(Enum.filter(loaded(env: Mix.env), &available?/1), opts)
      {opts, tail, _} ->
        compile(loaded_by_name(tail, [env: Mix.env] ++ opts), opts)
    end
  end

  @doc false
  def compile(deps, options \\ []) do
    shell  = Mix.shell
    config = Mix.Project.deps_config

    Mix.Task.run "deps.precompile"

    compiled =
      Enum.map(deps, fn %Mix.Dep{app: app, status: status, opts: opts, scm: scm} = dep ->

  end

  defp handle_rebar_not_found(%Mix.Dep{app: app, manager: manager}) do
    shell = Mix.shell()

    shell.info(
      "Could not find \"#{manager}\", which is needed to build dependency #{inspect(app)}"
    )

    shell.info("I can install a local copy which is just used by Mix")

    install_question =
      "Shall I install #{manager}? (if running non-interactively, " <>
        "use \"mix local.rebar --force\")"

    unless shell.yes?(install_question) do
      error_message =
        "Could not find \"#{manager}\" to compile " <>
          "dependency #{inspect(app)}, please ensure \"#{manager}\" is available"

      Mix.raise(error_message)
    end

    (Mix.Tasks.Local.Rebar.run([]) && Mix.Rebar.local_rebar_cmd(manager)) ||
      Mix.raise("\"#{manager}\" installation failed")
  end

  defp do_make(dep, config) do
