Revert "Add branch docs publishing"

This reverts commit 6f5cc529d5.

Latest ExDoc no longer works with this version.

.cirrus.yml

@@ -27,15 +27,13 @@ test_linux_task:
         - env:
             CHECK_POSIX_COMPLIANT: true
             CHECK_REPRODUCIBLE: true
-            OTP_RELEASE: OTP-22.1
+            OTP_RELEASE: OTP-23.0
+        - env:
+            OTP_RELEASE: OTP-22.3
         - env:
             OTP_RELEASE: OTP-22.0
         - env:
             OTP_RELEASE: OTP-21.3.8
-        - env:
-            OTP_RELEASE: OTP-21.2
-        - env:
-            OTP_RELEASE: OTP-21.1
         - env:
             OTP_RELEASE: OTP-21.0
 
@@ -110,7 +108,7 @@ test_windows_task:
     image: fertapric/elixir-ci:otp-win64-${OTP_RELEASE}
     os_version: ${OS_VERSION}
     cpu: 4
-    memory: 3840Mi
+    memory: 6GB
 
   install_script:
     - rmdir /s /q .git
@@ -130,11 +128,11 @@ test_windows_task:
 test_freebsd_task:
   <<: *DEFAULT_TEST_SETTINGS
 
-  name: FreeBSD 12.0
+  name: FreeBSD 12.1
   alias: FreeBSD Stable
 
   freebsd_instance:
-    image_family: freebsd-12-0
+    image_family: freebsd-12-1
     cpu: 8
     memory: 7424Mi
 
@@ -143,7 +141,6 @@ test_freebsd_task:
     LC_ALL: en_US.UTF-8
 
   install_script:
-    - sudo pkg update
     - pkg install -y erlang git gmake
     - rm -rf .git
     - gmake compile

CHANGELOG.md

@@ -74,7 +74,7 @@ iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], {:desc, Date})
 
 These API improvements make the code more concise and readable and they have also been added to `Enum.sort_by`, `Enum.min_by`, `Enum.max_by`, and friends.
 
-### Tracking of compile-time configuration
+## Tracking of compile-time configuration
 
 In Elixir, we organize our code in applications. Libraries, your dependencies, and your own project are all separate applications. All applications in Elixir also come with an application environment.
 
@@ -124,7 +124,7 @@ By using `compile_env/3`, Elixir will store the values used during compilation a
 
 In future versions, we will deprecate the use `Application.get_env` at compile-time with a clear message pointing users to configuration best practices, effectively addressing the scenario where users read from the application environment at compile time unaware of its pitfalls.
 
-### Compiler tracing
+## Compiler tracing
 
 This release brings enhancements to the Elixir compiler and adds new capabilities for developers to listen to compilation events.
 
@@ -141,7 +141,7 @@ Elixir itself is using the new compiler tracing to provide new functionality. On
 
 Previously, this information had to be added to the overall project configuration, which was far away from where the optional call effectively happened.
 
-### Other enhancements
+## Other enhancements
 
 Elixir's calendar data types got many improvements, such as sigil support for third-party calendars, as well as the additions of `DateTime.now!/2`, `DateTime.shift_zone!/3`, and `NaiveDateTime.local_now/0`.
 
@@ -153,7 +153,103 @@ ExUnit, our test framework, ships two small but important improvements: `ExUnit.
 assert %{"status" => 200, "body" => %{"key" => "foo"}} = json_payload
 ```
 
-Now imagine that `json_payload` is a large JSON blob and the `"key"` inside the `"body"` did not have value of `"foo"`. In previous Elixir versions, if the assertion failed, Elixir would print the right side and let you up to your own devices to figure out what went wrong. In Elixir v1.10, we diff the data structure against the pattern so you can see exactly which parts of the data matched the pattern and which ones did not. Note ExUnit already performed diffing when comparing data types, this new version adds diffing when matching data agaainst a pattern.
+Now imagine that `json_payload` is a large JSON blob and the `"key"` inside the `"body"` did not have value of `"foo"`. In previous Elixir versions, if the assertion failed, Elixir would print the right side and let you up to your own devices to figure out what went wrong. In Elixir v1.10, we diff the data structure against the pattern so you can see exactly which parts of the data matched the pattern and which ones did not. Note ExUnit already performed diffing when comparing data types, this new version adds diffing when matching data against a pattern.
+
+## v1.10.4 (2020-07-04)
+
+### 1. Bug fixes
+
+#### Elixir
+
+  * [Kernel] Fix a bug where custom types were printed as built-in types
+  * [Kernel] Don't add compile-time dependency on `defdelegate`
+  * [Kernel] Add line numbers to warnings on deprecated imports
+  * [Kernel] Report the correct line number when raising inside a macro
+  * [Task] Include callers in translated Logger metadata for Task
+  * [Task] Fix Task PID and caller in Task Supervisor reports
+
+#### ExUnit
+
+  * [ExUnit.Formatter] Avoid crashes when diffing guards when the pattern does not match
+  * [ExUnit.Formatter] Also blame exceptions that come from linked and trapped exits
+
+#### IEx
+
+  * [IEx.Helpers] Do not crash when printing a type that cannot be code formatted
+
+####  Mix
+
+  * [mix app.start] Fix reading `.app` file located in archives (`.ez` files)
+  * [mix local.hex] Provide more guidance when Hex can't be installed
+  * [mix release] Properly encode config in releases
+
+## v1.10.3 (2020-04-25)
+
+### 1. Bug fixes
+
+#### Elixir
+
+  * [Code] Return `[{mod, bin}]` from `Code.compile_file/2`, `Code.require_file/2`, `Code.load_file/2`
+  * [Code] Make sure the formatter respects newlines before and after module attributes
+  * [Kernel.ParallelCompiler] Fix a bug where the parallel compiler would raise in long compilation cycles
+  * [Kernel.ParallelCompiler] Fix a bug where the parallel compiler would raise if some of the modules being compiled referred to a module that has been loaded directly to memory
+  * [Module] Fix accidental breaking change where bodiless clauses had their body value on `@on_definition` callbacks set to an empty list instead of `nil`
+  * [String] Undeprecate `String.normalize/2` normalize and fix infinite loop caused by certain invalid strings
+
+#### ExUnit
+
+  * [ExUnit.Assertions] Fix pattern matching diff when matching on pinned variables
+  * [ExUnit.Assertions] Fix pattern matching diff when matching variable struct names
+  * [ExUnit.Assertions] Fix pattern matching diff when matching on the binary concat operator (`<>`) and the left side is not a literal string
+  * [ExUnit.Assertions] Fix pattern matching diff when matching on pseudo-vars (`__MODULE__`, `__DIR__`, etc)
+
+#### Mix
+
+  * [mix release] Respect the `:path` option when creating a `:tar` file for releases
+
+## v1.10.2 (2020-02-26)
+
+### 1. Bug fixes
+
+#### Elixir
+
+  * [Macro] Fix a bug where `Macro.to_string/1` would emit invalid code for sigils
+  * [Task] Do not crash `async_stream` monitor if it receives spurious DOWN messages
+
+#### Logger
+
+  * [Logger] Fix a bug where the Logger formatter would fail when handling unknown metadata values
+
+#### Mix
+
+  * [mix compile] Do not write files to disk if `--warnings-as-errors` was given and warnings were emitted
+
+## v1.10.1 (2020-02-10)
+
+### 1. Bug fixes
+
+#### Elixir
+
+  * [Code] Do not emit invalid code when formatting `nil`, `false`, and `true` keys in maps
+  * [Kernel] Ensure `with` clauses properly unpack "implicit guards" (such as matching on the struct name)
+  * [Kernel] Do not warn if commas are used by themselves in `~w`/`~W` sigils
+  * [Kernel] Do not validate the `:line` option in quote (the validation has been moved to v1.11 to give users more time to update their code)
+  * [Module] Ensure the code verifier handles the `:erlang.size/1` guard properly
+
+#### Logger
+
+  * [Logger] Properly handle the `report_cb/2` option from Erlang
+  * [Logger] Fix truncation for multi-byte characters
+  * [Logger] Do not rebroadcast messages from remote nodes as this is now taken care by Erlang's logger
+
+#### ExUnit
+
+  * [ExUnit] Ensure `assert_receive` produces valid exception messages in case of errors
+
+#### Mix
+
+  * [mix release] Make sure the install command (Window specific) works on paths with spaces in the name
+  * [mix release] Allow using `remote` and `rpc` commands with `Application.compile_env/3`
 
 ## v1.10.0 (2020-01-27)
 
@@ -179,6 +275,7 @@ Now imagine that `json_payload` is a large JSON blob and the `"key"` inside the
   * [Kernel] Warn when function head comes immediately after the implementation instead of before the implementation
   * [Kernel] Warn if duplicate key is found in struct declaration
   * [Kernel] Print all undefined functions as warnings and then raise. This allows users to see all undefined calls at once, when it would otherwise require them to compile the code multiple times
+  * [Kernel] Allow file, line and context to be dynamically set on `quote`
   * [Keyword] Add `Keyword.pop!/2` and `Keyword.pop_values/2`
   * [Map] Add `Map.pop!/2`
   * [MapSet] Optimize multiple operations
@@ -227,6 +324,7 @@ Now imagine that `json_payload` is a large JSON blob and the `"key"` inside the
 
   * [Enum] Allow positive range slices on infinite streams given to `Enum.slice/2`
   * [Kernel] Raise error on functions/guards without implementation
+  * [Kernel] Do not expand expressions inside interpolation twice
   * [Keyword] Ensure keyword replace and update preserve order
   * [Module] Raise instead of silently failing when performing a write module operation during after-compile
   * [Module] Fix `@macrocallback` definitions with a `when` clause
@@ -236,6 +334,10 @@ Now imagine that `json_payload` is a large JSON blob and the `"key"` inside the
   * [URI] Preserve slashes in URIs without authority
   * [URI] Require a nil or an absolute path on URIs with host or authority
 
+#### ExUnit
+
+  * [ExUnit.Assertions] Fix `assert_receive` and `assert match?` to behave consistently compared `receive` and `match?` when given an invalid macro
+
 #### IEx
 
   * [IEx] Exit IEx session if the group leader exits
@@ -280,6 +382,7 @@ Now imagine that `json_payload` is a large JSON blob and the `"key"` inside the
 #### Mix
 
   * [mix compile.xref] This check has been moved into the compiler and has no effect now
+  * [mix xref] `xref` now only tracks dependencies between modules and files, no longer between functions. See "Compilation tracers" to learn more about how to track this information directly
   * [mix xref deprecations] This check has been moved into the compiler and has no effect now
   * [mix xref unreachable] This check has been moved into the compiler and has no effect now
 

VERSION

@@ -1 +1 @@
-1.10.0
+1.10.4

lib/elixir/lib/calendar/datetime.ex

@@ -582,6 +582,10 @@ defmodule DateTime do
   It will return the integer with the given unit,
   according to `System.convert_time_unit/3`.
 
+  If you want to get the current time in Unix seconds,
+  do not do `DateTime.utc_now() |> DateTime.to_unix()`.
+  Simply call `System.os_time(:second)` instead.
+
   ## Examples
 
       iex> 1_464_096_368 |> DateTime.from_unix!() |> DateTime.to_unix()

lib/elixir/lib/code.ex

@@ -43,6 +43,15 @@ defmodule Code do
   You can configure your list of tracers via `put_compiler_option/2`. The
   following events are available to tracers:
 
+    * `:start` - (since v1.11.0) invoked whenever the compiler starts to trace
+      a new lexical context, such as a new file. Keep in mind the compiler runs
+      in parallel, so multiple files may invoke `:start` and run at the same
+      time. The value of the `lexical_tracker` of the macro environment, albeit
+      opaque, can be used to uniquely identify the environment.
+
+    * `:stop` - (since v1.11.0) invoked whenever the compiler stops tracing a
+      new lexical context, such as a new file.
+
     * `{:import, meta, module, opts}` - traced whenever `module` is imported.
       `meta` is the import AST metadata and `opts` are the import options.
 
@@ -75,8 +84,8 @@ defmodule Code do
       function or macro is referenced. `meta` is the call AST metadata, `module`
       is the invoked module, followed by the `name` and `arity`.
 
-    * `{:local_function, meta, module, name, arity}` and
-      `{:local_macro, meta, module, name, arity}` - traced whenever a local
+    * `{:local_function, meta, name, arity}` and
+      `{:local_macro, meta, name, arity}` - traced whenever a local
       function or macro is referenced. `meta` is the call AST metadata, `module`
       is the invoked module, followed by the `name` and `arity`.
 
@@ -1392,6 +1401,6 @@ defmodule Code do
   defp verify_loaded(loaded) do
     maps_binaries = Enum.map(loaded, fn {_module, map, binary} -> {map, binary} end)
     Module.ParallelChecker.verify(maps_binaries, [])
-    Enum.map(loaded, fn {module, map, _binary} -> {module, map} end)
+    Enum.map(loaded, fn {module, _map, binary} -> {module, binary} end)
   end
 end

lib/elixir/lib/code/formatter.ex

@@ -1914,8 +1914,7 @@ defmodule Code.Formatter do
     {args_docs, comments?, %{state | comments: comments}}
   end
 
-  defp each_quoted_to_algebra_with_comments(args, acc, max_line, state, comments?, fun) do
-    [arg | args] = args
+  defp each_quoted_to_algebra_with_comments([arg | args], acc, max_line, state, comments?, fun) do
     {doc_start, doc_end} = traverse_line(arg, {@max_line, @min_line})
 
     {acc, comments, comments?} =
@@ -1926,7 +1925,7 @@ defmodule Code.Formatter do
     {acc, comments, comments?} =
       extract_comments_trailing(doc_start, doc_end, acc, state.comments, comments?)
 
-    acc = [doc_triplet | acc]
+    acc = [adjust_trailing_newlines(doc_triplet, doc_end, comments) | acc]
     state = %{state | comments: comments}
     each_quoted_to_algebra_with_comments(args, acc, max_line, state, comments?, fun)
   end
@@ -1957,6 +1956,15 @@ defmodule Code.Formatter do
     {acc, rest, comments?}
   end
 
+  # If the document is immediately followed by comment which is followed by newlines,
+  # its newlines wouldn't have considerd the comment, so we need to adjust it.
+  defp adjust_trailing_newlines({doc, next_line, newlines}, doc_end, [{line, _, _} | _])
+       when newlines > 1 and line == doc_end + 1 do
+    {doc, next_line, 1}
+  end
+
+  defp adjust_trailing_newlines(doc_triplet, _, _), do: doc_triplet
+
   defp traverse_line({expr, meta, args}, {min, max}) do
     acc =
       case Keyword.fetch(meta, :line) do
@@ -2239,10 +2247,10 @@ defmodule Code.Formatter do
   defp keyword?(rest), do: rest == []
 
   defp keyword_key?({:__block__, meta, [atom]}) when is_atom(atom),
-    do: meta[:delimiter] != ":"
+    do: meta[:format] == :keyword
 
   defp keyword_key?({{:., _, [:erlang, :binary_to_atom]}, meta, [{:<<>>, _, _}, :utf8]}),
-    do: meta[:delimiter] != ":"
+    do: meta[:format] == :keyword
 
   defp keyword_key?(_),
     do: false

lib/elixir/lib/code/typespec.ex

@@ -217,7 +217,8 @@ defmodule Code.Typespec do
   end
 
   defp typespec_to_quoted({:user_type, line, name, args}) do
-    typespec_to_quoted({:type, line, name, args})
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    {name, [line: line], args}
   end
 
   defp typespec_to_quoted({:type, line, :tuple, :any}) do

lib/elixir/lib/config/provider.ex

@@ -110,7 +110,8 @@ defmodule Config.Provider do
     :config_path,
     extra_config: [],
     prune_after_boot: false,
-    reboot_after_config: true
+    reboot_after_config: true,
+    validate_compile_env: false
   ]
 
   @doc """
@@ -165,54 +166,74 @@ defmodule Config.Provider do
     # before we go around running Elixir code.
     {:ok, _} = :application.ensure_all_started(:elixir)
 
-    case :application.get_env(app, key) do
-      {:ok, %Config.Provider{} = provider} ->
-        path = resolve_config_path!(provider.config_path)
-        validate_no_cyclic_boot!(path)
-        loaded_applications = :application.loaded_applications()
-        original_config = read_config!(path)
+    # The key we store if the system already booted
+    booted_key = :"#{key}_booted"
 
-        config =
-          original_config
-          |> Config.__merge__(provider.extra_config)
-          |> run_providers(provider)
+    case :application.get_env(app, booted_key) do
+      {:ok, {:booted, path}} ->
+        path && File.rm(path)
 
-        if provider.reboot_after_config do
-          config
-          |> Config.__merge__([{app, [{key, booted_key(provider, path)}]}])
-          |> write_config!(path)
-
-          restart_fun.()
-        else
-          for {app, _, _} <- loaded_applications, config[app] != original_config[app] do
-            abort("""
-            Cannot configure #{inspect(app)} because :reboot_after_config has been set \
-            to false and #{inspect(app)} has already been loaded, meaning any further \
-            configuration won't have an effect.
-
-            The configuration for #{inspect(app)} before config providers was:
-
-            #{inspect(original_config[app])}
-
-            The configuration for #{inspect(app)} after config providers was:
-
-            #{inspect(config[app])}
-            """)
-          end
-
-          _ = Application.put_all_env(config, persistent: true)
-          :ok
+        with {:ok, %Config.Provider{} = provider} <- :application.get_env(app, key) do
+          maybe_validate_compile_env(provider)
         end
 
-      {:ok, {:booted, path}} ->
-        File.rm(path)
-        :booted
-
-      {:ok, :booted} ->
         :booted
 
       _ ->
-        :skip
+        case :application.get_env(app, key) do
+          {:ok, %Config.Provider{} = provider} ->
+            path = resolve_config_path!(provider.config_path)
+            reboot_config = [{app, [{booted_key, booted_value(provider, path)}]}]
+            boot_providers(path, provider, reboot_config, restart_fun)
+
+          _ ->
+            :skip
+        end
+    end
+  end
+
+  defp boot_providers(path, provider, reboot_config, restart_fun) do
+    validate_no_cyclic_boot!(path)
+    loaded_applications = :application.loaded_applications()
+    original_config = read_config!(path)
+
+    config =
+      original_config
+      |> Config.__merge__(provider.extra_config)
+      |> run_providers(provider)
+
+    if provider.reboot_after_config do
+      config
+      |> Config.__merge__(reboot_config)
+      |> write_config!(path)
+
+      restart_fun.()
+    else
+      for {app, _, _} <- loaded_applications, config[app] != original_config[app] do
+        abort("""
+        Cannot configure #{inspect(app)} because :reboot_after_config has been set \
+        to false and #{inspect(app)} has already been loaded, meaning any further \
+        configuration won't have an effect.
+
+        The configuration for #{inspect(app)} before config providers was:
+
+        #{inspect(original_config[app])}
+
+        The configuration for #{inspect(app)} after config providers was:
+
+        #{inspect(config[app])}
+        """)
+      end
+
+      _ = Application.put_all_env(config, persistent: true)
+      maybe_validate_compile_env(provider)
+      :ok
+    end
+  end
+
+  defp maybe_validate_compile_env(provider) do
+    with [_ | _] = compile_env <- provider.validate_compile_env do
+      validate_compile_env(compile_env)
     end
   end
 
@@ -283,8 +304,8 @@ defmodule Config.Provider do
     Process.sleep(:infinity)
   end
 
-  defp booted_key(%{prune_after_boot: true}, path), do: {:booted, path}
-  defp booted_key(%{prune_after_boot: false}, _path), do: :booted
+  defp booted_value(%{prune_after_boot: true}, path), do: {:booted, path}
+  defp booted_value(%{prune_after_boot: false}, _path), do: {:booted, nil}
 
   defp validate_no_cyclic_boot!(path) do
     if System.get_env("ELIXIR_CONFIG_PROVIDER_BOOTED") do
@@ -329,7 +350,7 @@ defmodule Config.Provider do
   defp write_config!(config, path) do
     contents = :io_lib.format("%% coding: utf-8~n~tw.~n", [config])
 
-    case File.write(path, contents, [:utf8]) do
+    case File.write(path, IO.chardata_to_string(contents)) do
       :ok ->
         :ok
 

lib/elixir/lib/gen_server.ex

@@ -640,7 +640,7 @@ defmodule GenServer do
   This callback is optional.
   """
   @callback terminate(reason, state :: term) :: term
-            when reason: :normal | :shutdown | {:shutdown, term}
+            when reason: :normal | :shutdown | {:shutdown, term} | term
 
   @doc """
   Invoked to change the state of the `GenServer` when a different version of a

lib/elixir/lib/io.ex

@@ -317,7 +317,7 @@ defmodule IO do
   @spec warn(chardata | String.Chars.t(), Exception.stacktrace()) :: :ok
   def warn(message, []) do
     message = [to_chardata(message), ?\n]
-    :elixir_errors.io_warn(nil, nil, message, message)
+    :elixir_errors.io_warn(0, nil, message, message)
   end
 
   def warn(message, [{_, _, _, opts} | _] = stacktrace) do
@@ -327,7 +327,7 @@ defmodule IO do
     file = opts[:file]
 
     :elixir_errors.io_warn(
-      line,
+      line || 0,
       file && List.to_string(file),
       message,
       [message, ?\n, "  ", formatted_trace, ?\n]

lib/elixir/lib/kernel.ex

@@ -2263,8 +2263,7 @@ defmodule Kernel do
       iex> get_in(users, ["john", :age])
       27
 
-  In case any of the entries in the middle returns `nil`, `nil` will
-  be returned as per the `Access` module:
+  In case any of the keys returns `nil`, `nil` will be returned:
 
       iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
       iex> get_in(users, ["unknown", :age])
@@ -2280,9 +2279,6 @@ defmodule Kernel do
     * a function to be invoked next
 
   This means `get_in/2` can be extended to provide custom lookups.
-  The downside is that functions cannot be stored as keys in the accessed
-  data structures.
-
   In the example below, we use a function to get all the maps inside
   a list:
 
@@ -4108,7 +4104,7 @@ defmodule Kernel do
       end
 
   """
-  defmacro def(call, expr \\ []) do
+  defmacro def(call, expr \\ nil) do
     define(:def, call, expr, __CALLER__)
   end
 
@@ -4138,7 +4134,7 @@ defmodule Kernel do
       ** (UndefinedFunctionError) undefined function Foo.sum/2
 
   """
-  defmacro defp(call, expr \\ []) do
+  defmacro defp(call, expr \\ nil) do
     define(:defp, call, expr, __CALLER__)
   end
 
@@ -4166,7 +4162,7 @@ defmodule Kernel do
       end
 
   """
-  defmacro defmacro(call, expr \\ []) do
+  defmacro defmacro(call, expr \\ nil) do
     define(:defmacro, call, expr, __CALLER__)
   end
 
@@ -4182,7 +4178,7 @@ defmodule Kernel do
   naming and default arguments.
 
   """
-  defmacro defmacrop(call, expr \\ []) do
+  defmacro defmacrop(call, expr \\ nil) do
     define(:defmacrop, call, expr, __CALLER__)
   end
 
@@ -4677,7 +4673,7 @@ defmodule Kernel do
             macro_definition =
               case impls do
                 [] ->
-                  define(kind, call, [], env)
+                  define(kind, call, nil, env)
 
                 [guard] ->
                   quoted =
@@ -4885,6 +4881,18 @@ defmodule Kernel do
   defmacro defdelegate(funs, opts) do
     funs = Macro.escape(funs, unquote: true)
 
+    # don't add compile-time dependency on :to
+    opts =
+      with true <- is_list(opts),
+           {:ok, target} <- Keyword.fetch(opts, :to),
+           {:__aliases__, _, _} <- target do
+        target = Macro.expand(target, %{__CALLER__ | function: {:__info__, 1}})
+        Keyword.replace!(opts, :to, target)
+      else
+        _ ->
+          opts
+      end
+
     quote bind_quoted: [funs: funs, opts: opts] do
       target =
         Keyword.get(opts, :to) || raise ArgumentError, "expected to: to be given as argument"
@@ -5388,7 +5396,8 @@ defmodule Kernel do
       true ->
         parts = String.split(string)
 
-        parts_with_trailing_comma = :lists.filter(&(:binary.last(&1) == ?,), parts)
+        parts_with_trailing_comma =
+          :lists.filter(&(byte_size(&1) > 1 and :binary.last(&1) == ?,), parts)
 
         if parts_with_trailing_comma != [] do
           stacktrace = Macro.Env.stacktrace(caller)

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -139,15 +139,15 @@ defmodule Kernel.ParallelCompiler do
     compiler_pid = self()
     :elixir_code_server.cast({:reset_warnings, compiler_pid})
     schedulers = max(:erlang.system_info(:schedulers_online), 2)
+    beam_timestamp = Keyword.get(options, :beam_timestamp)
 
-    result =
+    outcome =
       spawn_workers(files, 0, [], [], %{}, [], %{
         dest: Keyword.get(options, :dest),
         each_cycle: Keyword.get(options, :each_cycle, fn -> {:runtime, []} end),
         each_file: Keyword.get(options, :each_file, fn _, _ -> :ok end) |> each_file(),
         each_long_compilation: Keyword.get(options, :each_long_compilation, fn _file -> :ok end),
         each_module: Keyword.get(options, :each_module, fn _file, _module, _binary -> :ok end),
-        beam_timestamp: Keyword.get(options, :beam_timestamp),
         long_compilation_threshold: Keyword.get(options, :long_compilation_threshold, 15),
         profile: Keyword.get(options, :profile),
         cycle_start: System.monotonic_time(),
@@ -160,7 +160,7 @@ defmodule Kernel.ParallelCompiler do
     # compilation status will be set to error.
     compilation_status = :elixir_code_server.call({:compilation_status, compiler_pid})
 
-    case {result, compilation_status} do
+    case {outcome, compilation_status} do
       {{:ok, _, warnings}, :error} ->
         message = "Compilation failed due to warnings while using the --warnings-as-errors option"
         IO.puts(:stderr, message)
@@ -169,8 +169,11 @@ defmodule Kernel.ParallelCompiler do
       {{:error, errors, warnings}, :error} ->
         {:error, errors ++ warnings, []}
 
-      _ ->
-        result
+      {{:ok, outcome, warnings}, _} ->
+        {:ok, write_module_binaries(outcome, output, beam_timestamp), warnings}
+
+      {{:error, errors, warnings}, _} ->
+        {:error, errors, warnings}
     end
   end
 
@@ -187,6 +190,74 @@ defmodule Kernel.ParallelCompiler do
     end
   end
 
+  defp write_module_binaries(result, {:compile, path}, timestamp) do
+    Enum.flat_map(result, fn
+      {{:module, module}, {binary, _map}} ->
+        full_path = Path.join(path, Atom.to_string(module) <> ".beam")
+        File.write!(full_path, binary)
+        if timestamp, do: File.touch!(full_path, timestamp)
+        [module]
+
+      _ ->
+        []
+    end)
+  end
+
+  defp write_module_binaries(result, _output, _timestamp) do
+    for {{:module, module}, _} <- result, do: module
+  end
+
+  ## Verification
+
+  defp verify_modules(result, warnings, dependent_modules, state) do
+    checker_warnings = maybe_check_modules(result, dependent_modules, state)
+    warnings = Enum.reverse(warnings, checker_warnings)
+    {:ok, result, warnings}
+  end
+
+  defp maybe_check_modules(result, runtime_modules, state) do
+    %{schedulers: schedulers, profile: profile} = state
+
+    if :elixir_config.get(:bootstrap) do
+      []
+    else
+      compiled_modules = checker_compiled_modules(result)
+      runtime_modules = checker_runtime_modules(runtime_modules)
+
+      profile_checker(profile, compiled_modules, runtime_modules, fn ->
+        Module.ParallelChecker.verify(compiled_modules, runtime_modules, schedulers)
+      end)
+    end
+  end
+
+  defp checker_compiled_modules(result) do
+    for {{:module, _module}, {binary, module_map}} <- result do
+      {module_map, binary}
+    end
+  end
+
+  defp checker_runtime_modules(modules) do
+    for module <- modules,
+        path = :code.which(module),
+        is_list(path) and path != [] do
+      {module, File.read!(path)}
+    end
+  end
+
+  defp profile_checker(_profile = :time, compiled_modules, runtime_modules, fun) do
+    {time, result} = :timer.tc(fun)
+    time = div(time, 1000)
+    num_modules = length(compiled_modules) + length(runtime_modules)
+    IO.puts(:stderr, "[profile] Finished group pass check of #{num_modules} modules in #{time}ms")
+    result
+  end
+
+  defp profile_checker(_profile = nil, _compiled_modules, _runtime_modules, fun) do
+    fun.()
+  end
+
+  ## Compiler worker spawning
+
   # We already have n=schedulers currently running, don't spawn new ones
   defp spawn_workers(
          queue,
@@ -253,10 +324,10 @@ defmodule Kernel.ParallelCompiler do
 
     case each_cycle_return(state.each_cycle.()) do
       {:runtime, dependent_modules} ->
-        write_and_verify_modules(result, warnings, dependent_modules, state)
+        verify_modules(result, warnings, dependent_modules, state)
 
       {:compile, []} ->
-        write_and_verify_modules(result, warnings, [], state)
+        verify_modules(result, warnings, [], state)
 
       {:compile, more} ->
         spawn_workers(more, 0, [], [], result, warnings, state)
@@ -354,77 +425,13 @@ defmodule Kernel.ParallelCompiler do
   defp each_cycle_return(modules) when is_list(modules), do: {:compile, modules}
   defp each_cycle_return(other), do: other
 
-  defp write_and_verify_modules(result, warnings, dependent_modules, state) do
-    modules = write_module_binaries(result, state)
-    checker_warnings = maybe_check_modules(result, dependent_modules, state)
-    warnings = Enum.reverse(warnings, checker_warnings)
-    {:ok, modules, warnings}
-  end
-
-  defp write_module_binaries(result, %{output: {:compile, path}, beam_timestamp: timestamp}) do
-    Enum.flat_map(result, fn
-      {{:module, module}, {binary, _map}} ->
-        full_path = Path.join(path, Atom.to_string(module) <> ".beam")
-        File.write!(full_path, binary)
-        if timestamp, do: File.touch!(full_path, timestamp)
-        [module]
-
-      _ ->
-        []
-    end)
-  end
-
-  defp write_module_binaries(result, _state) do
-    for {{:module, module}, _} <- result, do: module
-  end
-
-  defp maybe_check_modules(result, runtime_modules, state) do
-    %{schedulers: schedulers, profile: profile} = state
-
-    if :elixir_config.get(:bootstrap) do
-      []
-    else
-      compiled_modules = checker_compiled_modules(result)
-      runtime_modules = checker_runtime_modules(runtime_modules)
-
-      profile_checker(profile, compiled_modules, runtime_modules, fn ->
-        Module.ParallelChecker.verify(compiled_modules, runtime_modules, schedulers)
-      end)
-    end
-  end
-
-  defp checker_compiled_modules(result) do
-    for {{:module, _module}, {binary, module_map}} <- result do
-      {module_map, binary}
-    end
-  end
-
-  defp checker_runtime_modules(modules) do
-    for module <- modules,
-        path = :code.which(module),
-        is_list(path) do
-      {module, File.read!(path)}
-    end
-  end
-
-  defp profile_checker(_profile = :time, compiled_modules, runtime_modules, fun) do
-    {time, result} = :timer.tc(fun)
-    time = div(time, 1000)
-    num_modules = length(compiled_modules) + length(runtime_modules)
-    IO.puts(:stderr, "[profile] Finished group pass check of #{num_modules} modules in #{time}ms")
-    result
-  end
-
-  defp profile_checker(_profile = nil, _compiled_modules, _runtime_modules, fun) do
-    fun.()
-  end
-
   # The goal of this function is to find leaves in the dependency graph,
   # i.e. to find code that depends on code that we know is not being defined.
+  # Note that not all files have been compile yet, so they may not be in waiting.
   defp without_definition(waiting, files) do
     nillify_empty(
       for {pid, _, _, _} <- files,
-          {_, ^pid, ref, on, _, _} = List.keyfind(waiting, pid, 1),
+          {_, ^pid, ref, on, _, _} <- List.wrap(List.keyfind(waiting, pid, 1)),
           not Enum.any?(waiting, fn {_, _, _, _, defining, _} -> on in defining end),
           do: {ref, :not_found}
     )
@@ -645,6 +652,12 @@ defmodule Kernel.ParallelCompiler do
     end
   end
 
+  defp get_line(file, _reason, [{_, _, _, [file: 'expanding macro']}, {_, _, _, info} | _]) do
+    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
+      Keyword.get(info, :line)
+    end
+  end
+
   defp get_line(file, _reason, [{_, _, _, info} | _]) do
     if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
       Keyword.get(info, :line)

lib/elixir/lib/kernel/special_forms.ex

@@ -14,7 +14,8 @@ defmodule Kernel.SpecialForms do
   forms used to define tuple and binary data structures respectively.
 
   This module also documents macros that return information about Elixir's
-  compilation environment, such as (`__ENV__/0`, `__MODULE__/0`, `__DIR__/0` and `__CALLER__/0`).
+  compilation environment, such as (`__ENV__/0`, `__MODULE__/0`, `__DIR__/0`,
+  `__STACKTRACE__/0`, and `__CALLER__/0`).
 
   Additionally, it documents two special forms, `__block__/1` and
   `__aliases__/1`, which are not intended to be called directly by the

lib/elixir/lib/macro.ex

@@ -163,8 +163,9 @@ defmodule Macro do
       with parens. The `:closing` does not delimit the end of expression if
       there are `:do` and `:end` metadata  (when `:token_metadata` is true)
     * `:column` - the column number of the AST node (when `:columns` is true)
-    * `:delimiter` - contains the opening delimiter for sigils, strings, atoms,
-      and charlists as a string (such as `"{"`, `"/"`, `":"`, and the like)
+    * `:delimiter` - contains the opening delimiter for sigils, strings,
+      and charlists as a string (such as `"{"`, `"/"`, `"'"`, and the like)
+    * `:format` - set to `:keyword` when an atom is defined as a keyword
     * `:do` - contains metadata about the `do` location in a function call with
       `do/end` blocks (when `:token_metadata` is true)
     * `:end` - contains metadata about the `end` location in a function call with
@@ -1021,11 +1022,11 @@ defmodule Macro do
 
         binary when is_binary(binary) ->
           binary = inspect_no_limit(binary)
-          binary_part(binary, 1, byte_size(binary) - 2)
+          binary = binary_part(binary, 1, byte_size(binary) - 2)
+          escape_sigil(binary, left)
       end)
 
-    escaped = escape_sigil(parts, left)
-    <<left::binary, escaped::binary, right::binary>>
+    <<left::binary, parts::binary, right::binary>>
   end
 
   defp escape_sigil(parts, "("), do: String.replace(parts, ")", ~S"\)")

lib/elixir/lib/map.ex

@@ -265,8 +265,6 @@ defmodule Map do
 
       iex> Map.fetch!(%{a: 1}, :a)
       1
-      iex> Map.fetch!(%{a: 1}, :b)
-      ** (KeyError) key :b not found in: %{a: 1}
 
   """
   @spec fetch!(map, key) :: value

lib/elixir/lib/module/checker.ex

@@ -231,7 +231,7 @@ defmodule Module.Checker do
 
   defp warn(meta, state, warning) do
     {fun, arity} = state.function
-    location = {state.file, meta[:line], {state.module, fun, arity}}
+    location = {state.file, meta[:line] || 0, {state.module, fun, arity}}
     %{state | warnings: [{__MODULE__, warning, location} | state.warnings]}
   end
 
@@ -306,7 +306,7 @@ defmodule Module.Checker do
 
   defp format_location({file, line, {module, fun, arity}}) do
     file = Path.relative_to_cwd(file)
-    line = if line, do: [Integer.to_string(line), ": "], else: []
+    line = if line > 0, do: [Integer.to_string(line), ": "], else: []
     mfa = Exception.format_mfa(module, fun, arity)
     ["  ", file, ?:, line, mfa, ?\n]
   end

lib/elixir/lib/module/types/pattern.ex

@@ -275,6 +275,7 @@ defmodule Module.Types.Pattern do
     {:binary_part, 3} => {[:binary, :integer, :integer], :binary},
     {:bit_size, 1} => {[:binary], :integer},
     {:byte_size, 1} => {[:binary], :integer},
+    {:size, 1} => {[{:union, [:binary, :tuple]}], :boolean},
     {:div, 2} => {[:integer, :integer], :integer},
     {:rem, 2} => {[:integer, :integer], :integer},
     {:node, 0} => {[], :atom},

lib/elixir/lib/port.ex

@@ -132,9 +132,9 @@ defmodule Port do
   While we encourage graceful termination by detecting if stdin/stdout has been
   closed, we do not always have control over how third-party software terminates.
   In those cases, you can wrap the application in a script that checks for stdin.
-  Here is such script in `sh`:
+  Here is such script that has been verified to work on bash shells:
 
-      #!/bin/sh
+      #!/usr/bin/env bash
 
       # Start the program in the background
       exec "$@" &

lib/elixir/lib/registry.ex

@@ -204,7 +204,7 @@ defmodule Registry do
   @type guards :: [guard]
 
   @typedoc "A pattern used to representing the output format part of a match spec"
-  @type body :: [atom | tuple]
+  @type body :: [term]
 
   @typedoc "A full match spec used when selecting objects in the registry"
   @type spec :: [{match_pattern, guards, body}]

lib/elixir/lib/stream.ex

@@ -107,6 +107,7 @@ defmodule Stream do
   @type index :: non_neg_integer
 
   @type default :: any
+  @type timer :: non_neg_integer | :infinity
 
   # Require Stream.Reducers and its callbacks
   require Stream.Reducers, as: R
@@ -505,8 +506,10 @@ defmodule Stream do
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
   """
-  @spec interval(non_neg_integer) :: Enumerable.t()
-  def interval(n) when is_integer(n) and n >= 0 do
+  @spec interval(timer()) :: Enumerable.t()
+  def interval(n)
+      when is_integer(n) and n >= 0
+      when n == :infinity do
     unfold(0, fn count ->
       Process.sleep(n)
       {count, count + 1}
@@ -787,8 +790,10 @@ defmodule Stream do
       [0]
 
   """
-  @spec timer(non_neg_integer) :: Enumerable.t()
-  def timer(n) when is_integer(n) and n >= 0 do
+  @spec timer(timer()) :: Enumerable.t()
+  def timer(n)
+      when is_integer(n) and n >= 0
+      when n == :infinity do
     take(interval(n), 1)
   end
 

lib/elixir/lib/string.ex

@@ -455,13 +455,13 @@ defmodule String do
   For example, take the grapheme "é" which is made of the characters
   "e" and the acute accent. The following will split the string into two parts:
 
-      iex> String.split(:unicode.characters_to_nfd_binary("é"), "e")
+      iex> String.split(String.normalize("é", :nfd), "e")
       ["", "́"]
 
   However, if "é" is represented by the single character "e with acute"
   accent, then it will split the string into just one part:
 
-      iex> String.split(:unicode.characters_to_nfc_binary("é"), "e")
+      iex> String.split(String.normalize("é", :nfc), "e")
       ["é"]
 
   """
@@ -650,9 +650,9 @@ defmodule String do
 
       String.normalize(string1, :nfd) == String.normalize(string2, :nfd)
 
-  Therefore, if you plan to compare multiple strings, multiple times
-  in a row, you may normalize them upfront and compare them directly
-  to avoid multiple normalization passes.
+  If you plan to compare multiple strings, multiple times in a row, you
+  may normalize them upfront and compare them directly to avoid multiple
+  normalization passes.
 
   ## Examples
 
@@ -674,21 +674,49 @@ defmodule String do
     normalize(string1, :nfd) == normalize(string2, :nfd)
   end
 
-  @doc false
-  @deprecated "Use :unicode.characters_to_nfc_binary/1 or :unicode.characters_to_nfd_binary/1 instead"
+  @doc """
+  Converts all characters in `string` to Unicode normalization
+  form identified by `form`.
+
+  Invalid Unicode codepoints are skipped and the remaining of
+  the string is converted. If you want the algorith to stop
+  and return on invalid codepoint, use `:unicode.characters_to_nfd_binary/1`
+  and `:unicode.characters_to_nfc_binary/1` instead.
+
+  ## Forms
+
+  The supported forms are:
+
+    * `:nfd` - Normalization Form Canonical Decomposition.
+      Characters are decomposed by canonical equivalence, and
+      multiple combining characters are arranged in a specific
+      order.
+
+    * `:nfc` - Normalization Form Canonical Composition.
+      Characters are decomposed and then recomposed by canonical equivalence.
+
+  ## Examples
+
+      iex> String.normalize("yêṩ", :nfd)
+      "yêṩ"
+
+      iex> String.normalize("leña", :nfc)
+      "leña"
+
+  """
   def normalize(string, form)
 
   def normalize(string, :nfd) do
     case :unicode.characters_to_nfd_binary(string) do
       string when is_binary(string) -> string
-      {:error, bad, rest} -> bad <> normalize(rest, :nfd)
+      {:error, good, <<head, rest::binary>>} -> good <> <<head>> <> normalize(rest, :nfd)
     end
   end
 
   def normalize(string, :nfc) do
     case :unicode.characters_to_nfc_binary(string) do
       string when is_binary(string) -> string
-      {:error, bad, rest} -> bad <> normalize(rest, :nfc)
+      {:error, good, <<head, rest::binary>>} -> good <> <<head>> <> normalize(rest, :nfc)
     end
   end
 
@@ -2174,13 +2202,13 @@ defmodule String do
   For example, take the grapheme "é" which is made of the characters
   "e" and the acute accent. The following returns `true`:
 
-      iex> String.contains?(:unicode.characters_to_nfd_binary("é"), "e")
+      iex> String.contains?(String.normalize("é", :nfd), "e")
       true
 
   However, if "é" is represented by the single character "e with acute"
   accent, then it will return `false`:
 
-      iex> String.contains?(:unicode.characters_to_nfc_binary("é"), "e")
+      iex> String.contains?(String.normalize("é", :nfc), "e")
       false
 
   """

lib/elixir/lib/task/supervised.ex

@@ -102,8 +102,8 @@ defmodule Task.Supervised do
           %{
             label: {Task.Supervisor, :terminating},
             report: %{
-              name: get_from(owner),
-              starter: self(),
+              name: self(),
+              starter: get_from(owner),
               function: fun,
               args: args,
               reason: {log_value(kind, value), __STACKTRACE__}
@@ -112,7 +112,8 @@ defmodule Task.Supervised do
           %{
             domain: [:otp, :elixir],
             error_logger: %{tag: :error_msg},
-            report_cb: &__MODULE__.format_report/1
+            report_cb: &__MODULE__.format_report/1,
+            callers: Process.get(:"$callers")
           }
         )
 
@@ -539,7 +540,7 @@ defmodule Task.Supervised do
 
       # One of the spawned processes went down. We inform the parent process of
       # this and keep going.
-      {:DOWN, ref, _, _, reason} ->
+      {:DOWN, ref, _, _, reason} when is_map_key(running_tasks, ref) ->
         {task, running_tasks} = Map.pop(running_tasks, ref)
         %{position: position, timer_ref: timer_ref, timed_out?: timed_out?} = task
 

lib/elixir/pages/Compatibility and Deprecations.md

@@ -52,7 +52,7 @@ Elixir version | Supported Erlang/OTP versions
 1.7            | 19 - 22
 1.8            | 20 - 22
 1.9            | 20 - 22
-1.10           | 21 - 22
+1.10           | 21 - 22 (and Erlang/OTP 23 from v1.10.3)
 
 While Elixir often adds compatibility to new Erlang/OTP versions on released branches, such as support for Erlang/OTP 20 in v1.4.5, those releases usually contain the minimum changes for Elixir to run without errors. Only the next minor release, in this case v1.5.0, does effectively leverage the new features provided by the latest Erlang/OTP release.
 
@@ -81,7 +81,6 @@ Version | Deprecated feature                                  | Replaced by (ava
 [v1.10] | Passing non-chardata to `Logger.log/2`              | Explicitly convert to string with `to_string/1` (v1.0)
 [v1.10] | `:compile_time_purge_level` in `Logger` app environment | `:compile_time_purge_matching` in `Logger` app environment (v1.7)
 [v1.10] | `Supervisor.Spec.supervise/2`                       | The new child specs outlined in `Supervisor` (v1.5)
-[v1.10] | `String.normalize/2`                                | `:unicode.characters_to_nfc_binary/1` or `:unicode.characters_to_nfd_binary/1` (Erlang/OTP 20)
 [v1.10] | `:simple_one_for_one` strategy in `Supervisor`      | `DynamicSupervisor` (v1.6)
 [v1.10] | `:restart` and `:shutdown` in `Task.Supervisor.start_link/1` | `:restart` and `:shutdown` in `Task.Supervisor.start_child/3` (v1.6)
 [v1.9]  | Enumerable keys in `Map.drop/2`, `Map.split/2`, and `Map.take/2` | Call `Enum.to_list/1` on the second argument before hand (v1.0)

lib/elixir/src/elixir_bootstrap.erl

@@ -10,11 +10,11 @@
 'MACRO-@'(Caller, Tree) ->
   unless_loaded('MACRO-@', [Caller, Tree], fun() -> nil end).
 
-'MACRO-def'(Caller, Call) -> 'MACRO-def'(Caller, Call, []).
+'MACRO-def'(Caller, Call) -> 'MACRO-def'(Caller, Call, nil).
 'MACRO-def'(Caller, Call, Expr) -> define(Caller, def, Call, Expr).
 'MACRO-defp'(Caller, Call, Expr) -> define(Caller, defp, Call, Expr).
 
-'MACRO-defmacro'(Caller, Call) -> 'MACRO-defmacro'(Caller, Call, []).
+'MACRO-defmacro'(Caller, Call) -> 'MACRO-defmacro'(Caller, Call, nil).
 'MACRO-defmacro'(Caller, Call, Expr) -> define(Caller, defmacro, Call, Expr).
 'MACRO-defmacrop'(Caller, Call, Expr) -> define(Caller, defmacrop, Call, Expr).
 

lib/elixir/src/elixir_def.erl

@@ -212,7 +212,7 @@ run_with_location_change(File, #{file := File} = E, Callback) ->
 run_with_location_change(File, E, Callback) ->
   elixir_lexical:with_file(File, E, Callback).
 
-def_to_clauses(_Kind, Meta, Args, [], [], E) ->
+def_to_clauses(_Kind, Meta, Args, [], nil, E) ->
   check_args_for_function_head(Meta, Args, E),
   [];
 def_to_clauses(_Kind, Meta, Args, Guards, [{do, Body}], _E) ->

lib/elixir/src/elixir_dispatch.erl

@@ -92,11 +92,25 @@ dispatch_import(Meta, Name, Args, E, Callback) ->
     {ok, Receiver, Quoted} ->
       expand_quoted(Meta, Receiver, Name, Arity, Quoted, E);
     {ok, Receiver, NewName, NewArgs} ->
-      elixir_expand:expand({{'.', [], [Receiver, NewName]}, Meta, NewArgs}, E);
+      elixir_expand:expand({{'.', Meta, [Receiver, NewName]}, Meta, NewArgs}, E);
     error ->
       Callback()
   end.
 
+dispatch_require(Meta, 'Elixir.System', stacktrace, [], #{contextual_vars := Vars} = E, Callback) ->
+  case lists:member('__STACKTRACE__', Vars) of
+    true ->
+      {{'__STACKTRACE__', [], nil}, E};
+    false ->
+      Message =
+        "System.stacktrace/0 outside of rescue/catch clauses is deprecated. "
+          "If you want to support only Elixir v1.7+, you must access __STACKTRACE__ "
+          "inside a rescue/catch. If you want to support earlier Elixir versions, "
+          "move System.stacktrace/0 inside a rescue/catch",
+      elixir_errors:erl_warn(?line(Meta), ?key(E, file), Message),
+      Callback('Elixir.System', stacktrace, [])
+  end;
+
 dispatch_require(Meta, Receiver, Name, Args, E, Callback) when is_atom(Receiver) ->
   Arity = length(Args),
 
@@ -314,9 +328,10 @@ get_macros(Receiver, false) ->
   end;
 
 get_macros(Receiver, true) ->
-  case is_ensure_loaded(Receiver) of
-    true -> get_info(Receiver, macros);
-    false -> []
+  try
+    Receiver:'__info__'(macros)
+  catch
+    error:_ -> []
   end.
 
 %% Kernel deprecations are inlined.
@@ -353,18 +368,6 @@ check_deprecated(_, erlang, _, _, _) ->
   ok;
 check_deprecated(_, _, _, _, #{module := 'Elixir.HashDict'}) ->
   ok;
-check_deprecated(Meta, 'Elixir.System', stacktrace, 0, #{contextual_vars := Vars} = E) ->
-  case lists:member('__STACKTRACE__', Vars) of
-    true ->
-      ok;
-    false ->
-      Message =
-        "System.stacktrace/0 outside of rescue/catch clauses is deprecated. "
-          "If you want to support only Elixir v1.7+, you must access __STACKTRACE__ "
-          "inside a rescue/catch. If you want to support earlier Elixir versions, "
-          "move System.stacktrace/0 inside a rescue/catch",
-      elixir_errors:erl_warn(?line(Meta), ?key(E, file), Message)
-  end;
 check_deprecated(Meta, Receiver, Name, Arity, E) ->
   case (?key(E, function) == nil) andalso is_ensure_loaded(Receiver) of
     true ->

lib/elixir/src/elixir_erl.erl

@@ -54,13 +54,8 @@ definition_to_anonymous(Module, Kind, Meta, Clauses) ->
   {value, Result, _Binding} = erl_eval:expr(Fun, [], {value, LocalHandler}),
   Result.
 
-invoke_local(Module, RawName, Args) ->
-  %% If we have a macro, its arity in the table is
-  %% actually one less than in the function call
-  {Name, Arity} = case atom_to_list(RawName) of
-    "MACRO-" ++ Rest -> {list_to_atom(Rest), length(Args) - 1};
-    _ -> {RawName, length(Args)}
-  end,
+invoke_local(Module, ErlName, Args) ->
+  {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, length(Args)),
 
   case elixir_def:local_for(Module, Name, Arity, all) of
     false ->

lib/elixir/src/elixir_erl_compiler.erl

@@ -48,8 +48,10 @@ compile(Forms, File, Opts) when is_list(Forms), is_list(Opts), is_binary(File) -
   case erl_to_core(Forms, Opts) of
     {ok, CoreForms, CoreWarnings} ->
       format_warnings(Opts, CoreWarnings),
+      CompileOpts = [?NO_SPAWN_COMPILER_PROCESS, from_core, no_core_prepare,
+                     no_auto_import, return, {source, Source} | Opts],
 
-      case compile:noenv_forms(CoreForms, [?NO_SPAWN_COMPILER_PROCESS, from_core, no_auto_import, return, {source, Source} | Opts]) of
+      case compile:noenv_forms(CoreForms, CompileOpts) of
         {ok, Module, Binary, Warnings} when is_binary(Binary) ->
           format_warnings(Opts, Warnings),
           {Module, Binary};
@@ -134,6 +136,14 @@ custom_format(sys_core_fold, {eval_failure, Error}) ->
   #{'__struct__' := Struct} = 'Elixir.Exception':normalize(error, Error),
   ["this expression will fail with ", elixir_aliases:inspect(Struct)];
 
+custom_format(sys_core_fold, {nomatch_shadow,Line,{ErlName,ErlArity}}) ->
+  {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, ErlArity),
+
+  io_lib:format(
+    "this clause for ~ts/~B cannot match because a previous clause at line ~B always matches",
+    [Name, Arity, Line]
+  );
+
 custom_format([], Desc) ->
   io_lib:format("~p", [Desc]);
 

lib/elixir/src/elixir_erl_pass.erl

@@ -409,8 +409,8 @@ translate_with_do([{'<-', Meta, [Left, Expr]} | Rest], Do, Else, S) ->
   {Args, Guards} = elixir_utils:extract_guards(Left),
   {TExpr, SR} = elixir_erl_pass:translate(Expr, S),
   {TArgs, SA} = elixir_erl_clauses:match(fun elixir_erl_pass:translate/2, Args, SR),
-  TGuards = elixir_erl_clauses:guards(Guards, [], SA),
-  {TBody, SB} = translate_with_do(Rest, Do, Else, SA),
+  TGuards = elixir_erl_clauses:guards(Guards, SA#elixir_erl.extra_guards, SA),
+  {TBody, SB} = translate_with_do(Rest, Do, Else, SA#elixir_erl{extra_guards=[]}),
 
   Clause = {clause, ?ann(Meta), [TArgs], TGuards, unblock(TBody)},
   {{'case', ?ann(?generated(Meta)), TExpr, [Clause, Else]}, SB};

lib/elixir/src/elixir_lexical.erl

@@ -10,6 +10,7 @@ run(#{tracers := Tracers} = E, ExecutionCallback, AfterExecutionCallback) ->
     false ->
       {ok, Pid} = ?tracker:start_link(),
       LexEnv = E#{lexical_tracker := Pid, tracers := [?MODULE | Tracers]},
+      elixir_env:trace(start, LexEnv),
 
       try ExecutionCallback(LexEnv) of
         Res ->
@@ -18,6 +19,7 @@ run(#{tracers := Tracers} = E, ExecutionCallback, AfterExecutionCallback) ->
           AfterExecutionCallback(LexEnv),
           Res
       after
+        elixir_env:trace(stop, LexEnv),
         unlink(Pid),
         ?tracker:stop(Pid)
       end;

lib/elixir/src/elixir_parser.yrl

@@ -259,9 +259,9 @@ access_expr -> bin_heredoc : build_bin_heredoc('$1').
 access_expr -> list_heredoc : build_list_heredoc('$1').
 access_expr -> bit_string : '$1'.
 access_expr -> sigil : build_sigil('$1').
-access_expr -> atom : handle_literal(?exprs('$1'), '$1', delimiter(<<$:>>)).
-access_expr -> atom_safe : build_quoted_atom('$1', true, delimiter(<<$:>>)).
-access_expr -> atom_unsafe : build_quoted_atom('$1', false, delimiter(<<$:>>)).
+access_expr -> atom : handle_literal(?exprs('$1'), '$1').
+access_expr -> atom_safe : build_quoted_atom('$1', true, []).
+access_expr -> atom_unsafe : build_quoted_atom('$1', false, []).
 access_expr -> dot_alias : '$1'.
 access_expr -> parens_call : '$1'.
 
@@ -526,12 +526,12 @@ call_args_parens -> open_paren call_args_parens_base ',' kw_base ',' close_paren
 
 % KV
 
-kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1').
-kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1').
-kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, []).
-kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, []).
-kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, []).
-kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, []).
+kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1', [{format, keyword}]).
+kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1', [{format, keyword}]).
+kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, [{format, keyword}]).
+kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, [{format, keyword}]).
+kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, [{format, keyword}]).
+kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, [{format, keyword}]).
 
 kw_base -> kw_eol container_expr : [{'$1', '$2'}].
 kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'} | '$1'].

lib/elixir/src/elixir_quote.erl

@@ -36,6 +36,8 @@ build(Meta, Line, File, Context, Unquote, Generated) ->
 
   {Q, Acc3}.
 
+validate_compile(_Meta, file, nil, Acc) ->
+  {nil, Acc};
 validate_compile(Meta, Key, Value, Acc) ->
   case is_valid(Key, Value) of
     true ->
@@ -55,13 +57,13 @@ validate_runtime(Key, Value) ->
       erlang:error(
         'Elixir.ArgumentError':exception(
           <<"invalid value for option :", (erlang:atom_to_binary(Key, utf8))/binary,
-            "in quote, got: ", ('Elixir.Kernel':inspect(Value))/binary>>
+            " in quote, got: ", ('Elixir.Kernel':inspect(Value))/binary>>
         )
       )
   end.
 
-is_valid(line, Line) -> is_integer(Line) orelse is_boolean(Line);
-is_valid(file, File) -> is_binary(File) orelse (File == nil);
+is_valid(line, _Line) -> true;
+is_valid(file, File) -> is_binary(File);
 is_valid(context, Context) -> is_atom(Context) andalso (Context /= nil);
 is_valid(generated, Generated) -> is_boolean(Generated);
 is_valid(unquote, Unquote) -> is_boolean(Unquote).

lib/elixir/src/elixir_utils.erl

@@ -7,15 +7,19 @@
   read_file_type/1, read_file_type/2, read_link_type/1, read_posix_mtime_and_size/1,
   change_posix_time/2, change_universal_time/2,
   guard_op/2, extract_splat_guards/1, extract_guards/1,
-  erlang_comparison_op_to_elixir/1]).
+  erlang_comparison_op_to_elixir/1, erl_fa_to_elixir_fa/2]).
 -include("elixir.hrl").
 -include_lib("kernel/include/file.hrl").
 
-% Builds the macro name
-
 macro_name(Macro) ->
   list_to_atom("MACRO-" ++ atom_to_list(Macro)).
 
+erl_fa_to_elixir_fa(Name, Arity) ->
+  case atom_to_list(Name) of
+    "MACRO-" ++ Rest -> {list_to_atom(Rest), Arity - 1};
+    _ -> {Name, Arity}
+  end.
+
 guard_op('andalso', 2) ->
   true;
 guard_op('orelse', 2) ->

lib/elixir/test/elixir/code_formatter/comments_test.exs

@@ -102,6 +102,108 @@ defmodule Code.Formatter.CommentsTest do
     end
   end
 
+  describe "modules attributes" do
+    test "with comments around" do
+      assert_same """
+      defmodule Sample do
+        # Comment 0
+        @moduledoc false
+        # Comment 1
+
+        # Comment 2
+        @attr1 1
+        # Comment 3
+
+        # Comment 4
+        @doc "Doc"
+        # Comment 5
+        @attr2 2
+        # Comment 6
+        def sample, do: :sample
+      end
+      """
+    end
+
+    test "with comments only after" do
+      assert_same """
+      @moduledoc false
+      # Comment 1
+
+      @attr 1
+      """
+    end
+
+    test "with too many new lines" do
+      bad = """
+      defmodule Sample do
+
+        # Comment 0
+
+
+        @moduledoc false
+
+
+        # Comment 1
+
+
+        # Comment 2
+
+
+        @attr1 1
+
+
+        # Comment 3
+
+
+        # Comment 4
+
+
+        @doc "Doc"
+
+
+        # Comment 5
+
+
+        @attr2 2
+
+
+        # Comment 6
+
+
+        def sample, do: :sample
+      end
+      """
+
+      assert_format bad, """
+      defmodule Sample do
+        # Comment 0
+
+        @moduledoc false
+
+        # Comment 1
+
+        # Comment 2
+
+        @attr1 1
+
+        # Comment 3
+
+        # Comment 4
+
+        @doc "Doc"
+
+        # Comment 5
+
+        @attr2 2
+
+        # Comment 6
+
+        def sample, do: :sample
+      end
+      """
+    end
+  end
+
   describe "interpolation" do
     test "with comment outside before, during and after" do
       assert_same ~S"""

lib/elixir/test/elixir/code_formatter/containers_test.exs

@@ -412,6 +412,11 @@ defmodule Code.Formatter.ContainersTest do
       assert_same map, @medium_length
     end
 
+    test "preserves user choice in regards to =>" do
+      assert_same "%{:hello => 1, :world => 2}"
+      assert_format "%{:true => 1, :false => 2}", "%{true => 1, false => 2}"
+    end
+
     test "preserves user choice even when it fits" do
       assert_same """
       %{

lib/elixir/test/elixir/code_test.exs

@@ -103,12 +103,18 @@ defmodule CodeTest do
   test "compile_file/1" do
     assert Code.compile_file(fixture_path("code_sample.exs")) == []
     refute fixture_path("code_sample.exs") in Code.required_files()
+
+    assert [{CompileSample, binary}] = Code.compile_file(fixture_path("compile_sample.ex"))
+    assert is_binary(binary)
+  after
+    :code.purge(CompileSample)
+    :code.delete(CompileSample)
   end
 
   test "compile_file/1 also emits checker warnings" do
     output =
       ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        Code.compile_file(PathHelpers.fixture_path("checker_warning.exs"))
+        Code.compile_file(fixture_path("checker_warning.exs"))
       end)
 
     assert output =~ "incompatible types"
@@ -122,8 +128,13 @@ defmodule CodeTest do
     Code.unrequire_files([fixture_path("code_sample.exs")])
     refute fixture_path("code_sample.exs") in Code.required_files()
     assert Code.require_file(fixture_path("code_sample.exs")) != nil
+
+    assert [{CompileSample, binary}] = Code.require_file(fixture_path("compile_sample.ex"))
+    assert is_binary(binary)
   after
-    Code.unrequire_files([fixture_path("code_sample.exs")])
+    Code.unrequire_files([fixture_path("code_sample.exs"), fixture_path("compile_sample.ex")])
+    :code.purge(CompileSample)
+    :code.delete(CompileSample)
   end
 
   describe "string_to_quoted/2" do
@@ -338,20 +349,22 @@ defmodule CodeTest do
       assert string_to_quoted.("0xEF") == {:__block__, [token: "0xEF", line: 1], [239]}
       assert string_to_quoted.("12.3") == {:__block__, [token: "12.3", line: 1], [12.3]}
       assert string_to_quoted.("nil") == {:__block__, [line: 1], [nil]}
-      assert string_to_quoted.(":one") == {:__block__, [delimiter: ":", line: 1], [:one]}
+      assert string_to_quoted.(":one") == {:__block__, [line: 1], [:one]}
 
-      args = [[{:__block__, [token: "1", line: 1], [1]}]]
+      assert string_to_quoted.("[one: :two]") == {
+               :__block__,
+               [{:closing, [line: 1]}, {:line, 1}],
+               [
+                 [
+                   {{:__block__, [format: :keyword, line: 1], [:one]},
+                    {:__block__, [line: 1], [:two]}}
+                 ]
+               ]
+             }
 
       assert string_to_quoted.("[1]") ==
-               {:__block__, [closing: [line: 1], line: 1], args}
-
-      args = [
-        {{:__block__, [delimiter: ":", line: 1], [:ok]},
-         {:__block__, [delimiter: ":", line: 1], [:test]}}
-      ]
-
-      assert string_to_quoted.("{:ok, :test}") ==
-               {:__block__, [closing: [line: 1], line: 1], args}
+               {:__block__, [closing: [line: 1], line: 1],
+                [[{:__block__, [token: "1", line: 1], [1]}]]}
 
       assert string_to_quoted.(~s("""\nhello\n""")) ==
                {:__block__, [delimiter: ~s["""], line: 1], ["hello\n"]}
@@ -359,16 +372,15 @@ defmodule CodeTest do
       assert string_to_quoted.("'''\nhello\n'''") ==
                {:__block__, [delimiter: ~s['''], line: 1], ['hello\n']}
 
-      args = [
-        {:->, [line: 1],
-         [
-           [{:__block__, [token: "1", line: 1, closing: [line: 1], line: 1], [1]}],
-           {:__block__, [delimiter: "\"", line: 1], ["hello"]}
-         ]}
-      ]
-
       assert string_to_quoted.(~s[fn (1) -> "hello" end]) ==
-               {:fn, [closing: [line: 1], line: 1], args}
+               {:fn, [closing: [line: 1], line: 1],
+                [
+                  {:->, [line: 1],
+                   [
+                     [{:__block__, [token: "1", line: 1, closing: [line: 1], line: 1], [1]}],
+                     {:__block__, [delimiter: "\"", line: 1], ["hello"]}
+                   ]}
+                ]}
     end
 
     test "raises on bad literal" do

lib/elixir/test/elixir/config/provider_test.exs

@@ -20,6 +20,7 @@ defmodule Config.ProviderTest do
 
     on_exit(fn ->
       Application.delete_env(@config_app, :config_providers)
+      Application.delete_env(@config_app, :config_providers_booted)
       System.delete_env(@env_var)
     end)
   end
@@ -79,14 +80,14 @@ defmodule Config.ProviderTest do
       init_and_assert_boot()
       config = consult(@sys_config)
       assert config[:my_app] == [key: :value]
-      assert config[@config_app] == [config_providers: :booted]
+      assert config[@config_app] == [config_providers_booted: {:booted, nil}]
     end
 
-    @tag sys_config: [my_app: [encoding: {:"£", "£", '£'}]]
+    @tag sys_config: [my_app: [encoding: {:time_μs, :"£", "£", '£'}]]
     test "writes sys_config with encoding" do
       init_and_assert_boot()
       config = consult(@sys_config)
-      assert config[:my_app][:encoding] == {:"£", "£", '£'}
+      assert config[:my_app][:encoding] == {:time_μs, :"£", "£", '£'}
     end
 
     @tag sys_config: [my_app: [key: :old_value, sys_key: :sys_value, extra_config: :old_value]]
@@ -113,6 +114,18 @@ defmodule Config.ProviderTest do
       refute File.exists?(@sys_config)
     end
 
+    test "returns :booted if already booted and runs validate_compile_env" do
+      init_and_assert_boot(
+        prune_after_boot: true,
+        validate_compile_env: [{:elixir, [:unknown], {:ok, :value}}]
+      )
+
+      Application.put_all_env(Keyword.take(consult(@sys_config), [@config_app]))
+
+      assert capture_abort(fn -> boot() end) =~
+               "the application :elixir has a different value set for key :unknown"
+    end
+
     test "raises if booting twice in a row" do
       init_and_assert_boot()
 
@@ -172,6 +185,6 @@ defmodule Config.ProviderTest do
   end
 
   defp write_sys_config!(data) do
-    File.write!(@sys_config, :io_lib.format("~tw.~n", [data]), [:utf8])
+    File.write!(@sys_config, IO.chardata_to_string(:io_lib.format("~tw.~n", [data])))
   end
 end

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -654,8 +654,8 @@ defmodule Kernel.ExpansionTest do
         expand(quote(do: [1] ++ 2 ++ [3] = [1, 2, 3]))
       end
 
-      assert {:=, _, [-1, {{:., [], [:erlang, :-]}, _, [1]}]} = expand(quote(do: -1 = -1))
-      assert {:=, _, [1, {{:., [], [:erlang, :+]}, _, [1]}]} = expand(quote(do: +1 = +1))
+      assert {:=, _, [-1, {{:., _, [:erlang, :-]}, _, [1]}]} = expand(quote(do: -1 = -1))
+      assert {:=, _, [1, {{:., _, [:erlang, :+]}, _, [1]}]} = expand(quote(do: +1 = +1))
 
       assert {:=, _, [[{:|, _, [1, [{:|, _, [2, 3]}]]}], [1, 2, 3]]} =
                expand(quote(do: [1] ++ [2] ++ 3 = [1, 2, 3]))

lib/elixir/test/elixir/kernel/lexical_tracker_test.exs

@@ -126,4 +126,21 @@ defmodule Kernel.LexicalTrackerTest do
     refute Foo.Bar in runtime
     refute Foo.Bar in compile
   end
+
+  test "defdelegate with literal does not add compile dependency" do
+    {{compile, _structs, _runtime, _}, _binding} =
+      Code.eval_string("""
+      defmodule Kernel.LexicalTrackerTest.Defdelegate do
+        defdelegate a, to: A
+
+        opts = [to: B]
+        defdelegate b, opts
+
+        Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+      end |> elem(3)
+      """)
+
+    refute A in compile
+    assert B in compile
+  end
 end

lib/elixir/test/elixir/kernel/parallel_compiler_test.exs

@@ -278,14 +278,17 @@ defmodule Kernel.ParallelCompilerTest do
           """
         )
 
+      output = tmp_path("not_to_be_used")
+
       try do
         Code.compiler_options(warnings_as_errors: true)
 
         msg =
           capture_io(:stderr, fn ->
-            assert {:error, [error], []} = Kernel.ParallelCompiler.compile([fixture])
-            msg = "this clause cannot match because a previous clause at line 2 always matches"
-            assert error == {fixture, 3, msg}
+            assert {:error, [error], []} =
+                     Kernel.ParallelCompiler.compile_to_path([fixture], output)
+
+            assert {^fixture, 3, "this clause " <> _} = error
           end)
 
         assert msg =~
@@ -294,6 +297,8 @@ defmodule Kernel.ParallelCompilerTest do
         Code.compiler_options(warnings_as_errors: warnings_as_errors)
         purge([WarningsSample])
       end
+
+      refute File.exists?(output)
     end
 
     test "does not use incorrect line number when error originates in another file" do
@@ -428,10 +433,7 @@ defmodule Kernel.ParallelCompilerTest do
           capture_io(:stderr, fn ->
             assert {:error, [error], []} = Kernel.ParallelCompiler.require([fixture])
 
-            message =
-              "this clause cannot match because a previous clause at line 2 always matches"
-
-            assert error == {fixture, 3, message}
+            assert {^fixture, 3, "this clause " <> _} = error
           end)
 
         assert msg =~

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -25,11 +25,6 @@ defmodule Kernel.QuoteTest do
   test "quote line var" do
     line = __ENV__.line
     assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: line], [1, 2, 3]}
-
-    assert_raise ArgumentError, fn ->
-      line = "oops"
-      quote(line: line, do: bar(1, 2, 3))
-    end
   end
 
   test "quote context var" do

lib/elixir/test/elixir/kernel/sigils_test.exs

@@ -66,6 +66,7 @@ bar) in ["foo\\\nbar", "foo\\\r\nbar"]
 
   test "sigil w" do
     assert ~w() == []
+    assert ~w([ , ]) == ["[", ",", "]"]
     assert ~w(foo bar baz) == ["foo", "bar", "baz"]
     assert ~w(foo #{:bar} baz) == ["foo", "bar", "baz"]
 
@@ -100,6 +101,7 @@ bar) in ["foo\\\nbar", "foo\\\r\nbar"]
 
   test "sigil W" do
     assert ~W() == []
+    assert ~W([ , ]) == ["[", ",", "]"]
     assert ~W(foo #{bar} baz) == ["foo", "\#{bar}", "baz"]
 
     assert ~W(foo\ bar) == ["foo\\", "bar"]

lib/elixir/test/elixir/kernel/tracers_test.exs

@@ -20,6 +20,15 @@ defmodule Kernel.TracersTest do
     end)
   end
 
+  test "traces start and stop" do
+    compile_string("""
+    Foo
+    """)
+
+    assert_receive {:start, %{lexical_tracker: pid}} when is_pid(pid)
+    assert_receive {:stop, %{lexical_tracker: pid}} when is_pid(pid)
+  end
+
   test "traces alias references" do
     compile_string("""
     Foo

lib/elixir/test/elixir/kernel/warning_test.exs

@@ -661,24 +661,6 @@ defmodule Kernel.WarningTest do
     purge(Sample)
   end
 
-  test "previous clause always matches" do
-    assert capture_err(fn ->
-             Code.eval_string("""
-             defmodule Sample do
-               def binary_cond do
-                 v = "bc"
-                 cond do
-                   is_binary(v) -> :bin
-                   true -> :ok
-                 end
-               end
-             end
-             """)
-           end) =~ "this clause cannot match because a previous clause at line 5 always matches"
-  after
-    purge(Sample)
-  end
-
   test "late function heads" do
     assert capture_err(fn ->
              Code.eval_string("""
@@ -740,7 +722,8 @@ defmodule Kernel.WarningTest do
                def hello, do: nil
              end
              """)
-           end) =~ "this clause cannot match because a previous clause at line 2 always matches"
+           end) =~
+             ~r"this clause( for hello/0)? cannot match because a previous clause at line 2 always matches"
   after
     purge(Sample)
   end
@@ -760,7 +743,8 @@ defmodule Kernel.WarningTest do
                use Sample
              end
              """)
-           end) =~ "this clause cannot match because a previous clause at line 10 always matches"
+           end) =~
+             ~r"this clause( for hello/0)? cannot match because a previous clause at line 10 always matches"
   after
     purge(Sample)
     purge(UseSample)
@@ -1628,7 +1612,8 @@ defmodule Kernel.WarningTest do
                defguard foo(baz) when baz == :baz
              end
              """)
-           end) =~ "this clause cannot match because a previous clause at line 2 always matches"
+           end) =~
+             ~r"this clause( for foo/1)? cannot match because a previous clause at line 2 always matches"
   after
     purge(Sample)
   end
@@ -1641,7 +1626,8 @@ defmodule Kernel.WarningTest do
                defmacro foo(bar), do: bar == :bar
              end
              """)
-           end) =~ "this clause cannot match because a previous clause at line 2 always matches"
+           end) =~
+             ~r"this clause( for foo/1)? cannot match because a previous clause at line 2 always matches"
   after
     purge(Sample)
   end

lib/elixir/test/elixir/kernel/with_test.exs

@@ -73,6 +73,16 @@ defmodule Kernel.WithTest do
     assert state == 1
   end
 
+  test "with extra guards" do
+    var =
+      with %_{} = a <- struct(URI),
+           %_{} <- a do
+        :ok
+      end
+
+    assert var == :ok
+  end
+
   test "errors in with" do
     assert_raise RuntimeError, fn ->
       with({:ok, res} <- oops(), do: res)

lib/elixir/test/elixir/macro_test.exs

@@ -344,6 +344,7 @@ defmodule MacroTest do
       assert Macro.to_string(quote(do: ~R"\n123")) == ~S/~R"\n123"/
 
       assert Macro.to_string(quote(do: ~S["'(123)'"])) == ~S/~S["'(123)'"]/
+      assert Macro.to_string(quote(do: ~s"#{"foo"}")) == ~S/~s"#{"foo"}"/
 
       assert Macro.to_string(
                quote do
@@ -704,6 +705,12 @@ defmodule MacroTest do
       assert Macro.to_string(quote(do: 'abc')) == "'abc'"
     end
 
+    test "string" do
+      assert Macro.to_string(quote(do: "")) == ~S/""/
+      assert Macro.to_string(quote(do: "abc")) == ~S/"abc"/
+      assert Macro.to_string(quote(do: "#{"abc"}")) == ~S/"#{"abc"}"/
+    end
+
     test "last arg keyword list" do
       assert Macro.to_string(quote(do: foo([]))) == "foo([])"
       assert Macro.to_string(quote(do: foo(x: y))) == "foo(x: y)"

lib/elixir/test/elixir/module/checker_test.exs

@@ -639,6 +639,31 @@ defmodule Module.CheckerTest do
       assert_warnings(files, warning)
     end
 
+    test "reports imported functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          def a, do: :ok
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          import A
+          def b, do: a()
+        end
+        """
+      }
+
+      warning = """
+      warning: A.a/0 is deprecated. oops
+        b.ex:3: B.b/0
+
+      """
+
+      assert_warnings(files, warning)
+    end
+
     test "reports structs" do
       files = %{
         "a.ex" => """

lib/elixir/test/elixir/module/types_test.exs

@@ -161,6 +161,11 @@ defmodule Module.TypesTest do
                quoted_head([x], [is_tuple(is_atom(x))])
     end
 
+    test "erlang-only guards" do
+      assert quoted_head([x], [:erlang.size(x)]) ==
+               {:ok, [{:union, [:binary, :tuple]}]}
+    end
+
     test "failing guard functions" do
       assert quoted_head([x], [length([])]) == {:ok, [{:var, 0}]}
 

lib/elixir/test/elixir/regex_test.exs

@@ -91,8 +91,10 @@ defmodule RegexTest do
     assert <<0xA0::utf8>> =~ ~r/[[:space:]]/u
     assert <<0xA0::utf8>> =~ ~r/\s/u
 
+    # Erlang/OTP 23 raises badarg on invalid UTF-8.
+    # Earlier versions simply would not match.
+    assert catch_error(if <<?<, 255, ?>>> =~ ~r/<.>/u, do: flunk("failed"), else: raise("failed"))
     assert <<?<, 255, ?>>> =~ ~r/<.>/
-    refute <<?<, 255, ?>>> =~ ~r/<.>/u
   end
 
   test "ungreedy" do
@@ -349,6 +351,6 @@ defmodule RegexTest do
   end
 
   defp matches_escaped?(string, match) do
-    Regex.match?(~r/#{Regex.escape(string)}/simxu, match)
+    Regex.match?(~r/#{Regex.escape(string)}/simx, match)
   end
 end

lib/elixir/test/elixir/stream_test.exs

@@ -499,13 +499,17 @@ defmodule StreamTest do
 
   test "interval/1" do
     stream = Stream.interval(10)
-
     {time_us, value} = :timer.tc(fn -> Enum.take(stream, 5) end)
 
     assert value == [0, 1, 2, 3, 4]
     assert time_us >= 50000
   end
 
+  test "interval/1 with infinity" do
+    stream = Stream.interval(:infinity)
+    spawn(Stream, :run, [stream])
+  end
+
   test "into/2 and run/1" do
     Process.put(:stream_cont, [])
     Process.put(:stream_done, false)
@@ -1119,6 +1123,11 @@ defmodule StreamTest do
     assert time_us >= 5000
   end
 
+  test "timer/1 with infinity" do
+    stream = Stream.timer(:infinity)
+    spawn(Stream, :run, [stream])
+  end
+
   test "unfold/2" do
     stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x - 1} end)
     assert Enum.take(stream, 5) == [10, 9, 8, 7, 6]

lib/elixir/test/elixir/string_test.exs

@@ -749,4 +749,79 @@ defmodule StringTest do
     assert String.myers_difference("abc", "aйbc") == [eq: "a", ins: "й", eq: "bc"]
     assert String.myers_difference("aйbc", "abc") == [eq: "a", del: "й", eq: "bc"]
   end
+
+  test "normalize/2" do
+    assert String.normalize("ŝ", :nfd) == "ŝ"
+    assert String.normalize("ḇravô", :nfd) == "ḇravô"
+    assert String.normalize("ṩierra", :nfd) == "ṩierra"
+    assert String.normalize("뢴", :nfd) == "뢴"
+    assert String.normalize("êchǭ", :nfc) == "êchǭ"
+    assert String.normalize("거̄", :nfc) == "거̄"
+    assert String.normalize("뢴", :nfc) == "뢴"
+
+    ## Error cases
+    assert String.normalize(<<15, 216>>, :nfc) == <<15, 216>>
+    assert String.normalize(<<15, 216>>, :nfd) == <<15, 216>>
+    assert String.normalize(<<216, 15>>, :nfc) == <<216, 15>>
+    assert String.normalize(<<216, 15>>, :nfd) == <<216, 15>>
+
+    ## Cases from NormalizationTest.txt
+
+    # 05B8 05B9 05B1 0591 05C3 05B0 05AC 059F
+    # 05B1 05B8 05B9 0591 05C3 05B0 05AC 059F
+    # HEBREW POINT QAMATS, HEBREW POINT HOLAM, HEBREW POINT HATAF SEGOL,
+    # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,
+    # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA
+    assert String.normalize("ֱָֹ֑׃ְ֬֟", :nfc) == "ֱָֹ֑׃ְ֬֟"
+
+    # 095D (exclusion list)
+    # 0922 093C
+    # DEVANAGARI LETTER RHA
+    assert String.normalize("ढ़", :nfc) == "ढ़"
+
+    # 0061 0315 0300 05AE 0340 0062
+    # 00E0 05AE 0300 0315 0062
+    # LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT,
+    # HEBREW ACCENT ZINOR, COMBINING GRAVE TONE MARK, LATIN SMALL LETTER B
+    assert String.normalize("à֮̀̕b", :nfc) == "à֮̀̕b"
+
+    # 0344
+    # 0308 0301
+    # COMBINING GREEK DIALYTIKA TONOS
+    assert String.normalize("\u0344", :nfc) == "\u0308\u0301"
+
+    # 115B9 0334 115AF
+    # 115B9 0334 115AF
+    # SIDDHAM VOWEL SIGN AI, COMBINING TILDE OVERLAY, SIDDHAM VOWEL SIGN AA
+    assert String.normalize("𑖹̴𑖯", :nfc) == "𑖹̴𑖯"
+    # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,
+    # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA
+    assert String.normalize("ֱָֹ֑׃ְ֬֟", :nfc) == "ֱָֹ֑׃ְ֬֟"
+
+    # 095D (exclusion list)
+    # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,
+    # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA
+    assert String.normalize("ֱָֹ֑׃ְ֬֟", :nfc) == "ֱָֹ֑׃ְ֬֟"
+
+    # 095D (exclusion list)
+    # 0922 093C
+    # DEVANAGARI LETTER RHA
+    assert String.normalize("ढ़", :nfc) == "ढ़"
+
+    # 0061 0315 0300 05AE 0340 0062
+    # 00E0 05AE 0300 0315 0062
+    # LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT,
+    # HEBREW ACCENT ZINOR, COMBINING GRAVE TONE MARK, LATIN SMALL LETTER B
+    assert String.normalize("à֮̀̕b", :nfc) == "à֮̀̕b"
+
+    # 0344
+    # 0308 0301
+    # COMBINING GREEK DIALYTIKA TONOS
+    assert String.normalize("\u0344", :nfc) == "\u0308\u0301"
+
+    # 115B9 0334 115AF
+    # 115B9 0334 115AF
+    # SIDDHAM VOWEL SIGN AI, COMBINING TILDE OVERLAY, SIDDHAM VOWEL SIGN AA
+    assert String.normalize("𑖹̴𑖯", :nfc) == "𑖹̴𑖯"
+  end
 end

lib/elixir/test/elixir/task_test.exs

@@ -584,6 +584,21 @@ defmodule TaskTest do
       [ok: :ok] = Task.async_stream([1], fn _ -> :ok end, timeout: :infinity) |> Enum.to_list()
     end
 
+    test "streams with fake down messages on the inbox" do
+      parent = self()
+
+      assert Task.async_stream([:ok], fn :ok ->
+               {:links, links} = Process.info(self(), :links)
+
+               for link <- links do
+                 send(link, {:DOWN, make_ref(), :process, parent, :oops})
+               end
+
+               :ok
+             end)
+             |> Enum.to_list() == [ok: :ok]
+    end
+
     test "with $callers" do
       grandparent = self()
 

lib/elixir/test/elixir/typespec_test.exs

@@ -1183,6 +1183,12 @@ defmodule TypespecTest do
       quoted =
         Enum.sort([
           quote(do: @spec(foo() :: integer())),
+          quote(do: @spec(foo() :: union())),
+          quote(do: @spec(foo() :: union(integer()))),
+          quote(do: @spec(foo() :: truly_union())),
+          quote(do: @spec(foo(union()) :: union())),
+          quote(do: @spec(foo(union(integer())) :: union(integer()))),
+          quote(do: @spec(foo(truly_union()) :: truly_union())),
           quote(do: @spec(foo(atom()) :: integer() | [{}])),
           quote(do: @spec(foo(arg) :: integer() when [arg: integer()])),
           quote(do: @spec(foo(arg) :: arg when [arg: var])),
@@ -1191,6 +1197,10 @@ defmodule TypespecTest do
 
       bytecode =
         test_module do
+          @type union :: any()
+          @type union(t) :: t
+          @type truly_union :: list | map | union
+
           def foo(), do: 1
           def foo(arg), do: arg
           Module.eval_quoted(__MODULE__, quote(do: (unquote_splicing(quoted))))

lib/ex_unit/examples/one_of_each.exs

@@ -1,4 +1,4 @@
-ExUnit.start [seed: 0]
+ExUnit.start(seed: 0)
 
 defmodule TestOneOfEach do
   @moduledoc """
@@ -10,8 +10,8 @@ defmodule TestOneOfEach do
   @one 1
   @two 2
 
-  @long_data_1  [field1: "one", field2: {:two1, :two2}, field3: 'three', field4: [1, 2, 3, 4]]
-  @long_data_2  [field1: "one", field2: {:two1, :two3}, field3: 'three', field4: [1, 2, 3, 4]]
+  @long_data_1 [field1: "one", field2: {:two1, :two2}, field3: 'three', field4: [1, 2, 3, 4]]
+  @long_data_2 [field1: "one", field2: {:two1, :two3}, field3: 'three', field4: [1, 2, 3, 4]]
 
   setup do
     {:ok, user_id: 1, post_id: 2, many_ids: Enum.to_list(1..50)}
@@ -62,10 +62,10 @@ defmodule TestOneOfEach do
   end
 
   test "12. assert that a message is received within a timeout" do
-    send self(), {:ok, 1}
-    send self(), :message_in_my_inbox
-    send self(), {:ok, 2}
-    send self(), :another_message
+    send(self(), {:ok, 1})
+    send(self(), :message_in_my_inbox)
+    send(self(), {:ok, 2})
+    send(self(), :another_message)
     assert_receive :no_message_after_timeout
   end
 
@@ -75,14 +75,14 @@ defmodule TestOneOfEach do
 
   test "14. assert an exception with a given message is raised" do
     assert_raise(SomeException, "some message", fn ->
-                                                     raise "other exception"
-                                                end)
+      raise "other exception"
+    end)
   end
 
   test "15. assert an exception with a given message is raised, but the message is wrong" do
     assert_raise(RuntimeError, "some message", fn ->
-                                                    raise "other error"
-                                               end)
+      raise "other error"
+    end)
   end
 
   test "16. assert an exception is raised" do
@@ -90,7 +90,7 @@ defmodule TestOneOfEach do
   end
 
   test "17. assert two values are within some delta" do
-    assert_in_delta 3.1415926, 22.0/7, 0.001
+    assert_in_delta 3.1415926, 22.0 / 7, 0.001
   end
 
   test "18. refute a value with a message" do
@@ -98,12 +98,12 @@ defmodule TestOneOfEach do
   end
 
   test "19. refute a message is received within a timeout" do
-    send self(), {:hello, "Dave"}
+    send(self(), {:hello, "Dave"})
     refute_receive {:hello, _}, 1000
   end
 
   test "20. refute a message is ready to be received" do
-    send self(), :hello_again
+    send(self(), :hello_again)
     refute_received :hello_again
   end
 
@@ -116,7 +116,7 @@ defmodule TestOneOfEach do
   end
 
   test "23. flunk" do
-    flunk "we failed. totally"
+    flunk("we failed. totally")
   end
 
   test "24. exception raised while running test" do
@@ -124,7 +124,8 @@ defmodule TestOneOfEach do
   end
 
   test "25. error due to exit" do
-    spawn_link fn -> raise "oops" end
+    spawn_link(fn -> raise "oops" end)
+
     receive do
     end
   end
@@ -133,15 +134,17 @@ defmodule TestOneOfEach do
     error1 =
       try do
         assert [@one] = [@two]
-      rescue e in ExUnit.AssertionError ->
-        {:error, e, System.stacktrace}
+      rescue
+        e in ExUnit.AssertionError ->
+          {:error, e, __STACKTRACE__}
       end
 
     error2 =
       try do
         assert @one * 4 > @two * 3
-      rescue e in ExUnit.AssertionError ->
-        {:error, e, System.stacktrace}
+      rescue
+        e in ExUnit.AssertionError ->
+          {:error, e, __STACKTRACE__}
       end
 
     raise ExUnit.MultiError, errors: [error1, error2]
@@ -150,8 +153,8 @@ defmodule TestOneOfEach do
   @tag capture_log: true
   test "27. log capturing" do
     require Logger
-    Logger.debug "this will be logged"
-    flunk "oops"
+    Logger.debug("this will be logged")
+    flunk("oops")
   end
 
   test "28. function clause error" do
@@ -162,6 +165,28 @@ defmodule TestOneOfEach do
     assert some_vars(1 + 2, 3 + 4)
   end
 
+  @tag :capture_log
+  test "30. linked assertion error" do
+    Task.async(fn -> assert 1 == 2 end) |> Task.await()
+  end
+
+  @tag :capture_log
+  test "31. linked function clause error" do
+    Task.async(fn -> Access.fetch(:foo, :bar) end) |> Task.await()
+  end
+
+  @tag :capture_log
+  test "32. trapped assertion error" do
+    Process.flag(:trap_exit, true)
+    Task.async(fn -> assert 1 == 2 end) |> Task.await()
+  end
+
+  @tag :capture_log
+  test "33. trapped function clause error" do
+    Process.flag(:trap_exit, true)
+    Task.async(fn -> Access.fetch(:foo, :bar) end) |> Task.await()
+  end
+
   defp some_vars(_a, _b) do
     false
   end
@@ -171,6 +196,6 @@ defmodule TestOneOfEach do
   end
 
   defp ignite(val) do
-    1/val
+    1 / val
   end
 end

lib/ex_unit/lib/ex_unit/diff.ex

@@ -57,7 +57,8 @@ defmodule ExUnit.Diff do
   end
 
   defp diff_quoted({name, _, context} = left, right, env)
-       when is_atom(name) and is_atom(context) do
+       when is_atom(name) and is_atom(context) and
+              name not in [:__MODULE__, :__DIR__, :__STACKTRACE__, :__ENV__, :__CALLER__] do
     diff_var(left, right, env)
   end
 
@@ -81,20 +82,16 @@ defmodule ExUnit.Diff do
     diff_tuple(Tuple.to_list(left), Tuple.to_list(right), env)
   end
 
-  defp diff_quoted({:%, _, [struct, {:%{}, _, kw}]}, %{} = right, env)
-       when is_atom(struct) and is_list(kw) do
-    diff_quoted_struct([__struct__: struct] ++ kw, struct, right, env)
+  defp diff_quoted({:%, _, [struct, {:%{}, _, kw}]}, %{} = right, env) when is_list(kw) do
+    diff_quoted_struct([__struct__: struct] ++ kw, right, env)
   end
 
-  defp diff_quoted({:%{}, _, items}, %{} = right, env) when is_list(items) do
-    if struct = items[:__struct__] do
-      diff_quoted_struct(items, struct, right, env)
-    else
-      diff_map(items, right, nil, maybe_struct(right), env)
-    end
+  defp diff_quoted({:%{}, _, kw}, %{} = right, env) when is_list(kw) do
+    diff_quoted_struct(kw, right, env)
   end
 
-  defp diff_quoted({:<>, _, _} = left, right, env) when is_binary(right) do
+  defp diff_quoted({:<>, _, [literal, _]} = left, right, env)
+       when is_binary(literal) and is_binary(right) do
     diff_string_concat(left, right, env)
   end
 
@@ -183,13 +180,18 @@ defmodule ExUnit.Diff do
   defp diff_guard({:when, _, [expression, clause]}, right, env) do
     {diff_expression, post_env} = diff_quoted(expression, right, env)
 
-    bindings = Map.merge(post_env.pins, post_env.current_vars)
-    {diff_clause, clause_equivalent?} = diff_guard_clause(clause, Map.to_list(bindings))
+    {guard_clause, guard_equivalent?} =
+      if diff_expression.equivalent? do
+        bindings = Map.merge(post_env.pins, post_env.current_vars)
+        diff_guard_clause(clause, Map.to_list(bindings))
+      else
+        {clause, false}
+      end
 
     diff = %__MODULE__{
       diff_expression
-      | left: {:when, [], [diff_expression.left, diff_clause]},
-        equivalent?: diff_expression.equivalent? and clause_equivalent?
+      | left: {:when, [], [diff_expression.left, guard_clause]},
+        equivalent?: guard_equivalent?
     }
 
     {diff, post_env}
@@ -225,7 +227,7 @@ defmodule ExUnit.Diff do
   defp diff_pin({:^, _, [var]} = pin, right, %{pins: pins} = env) do
     identifier = var_context(var)
     %{^identifier => pin_value} = pins
-    {diff, post_env} = diff(pin_value, right, env)
+    {diff, post_env} = diff_value(pin_value, right, env)
 
     diff_left = update_diff_meta(pin, not diff.equivalent?)
     {%{diff | left: diff_left}, post_env}
@@ -626,8 +628,9 @@ defmodule ExUnit.Diff do
 
   # Structs
 
-  defp diff_quoted_struct(kw, struct1, right, env) do
-    left = load_struct(struct1)
+  defp diff_quoted_struct(kw, right, env) do
+    struct1 = kw[:__struct__]
+    left = load_struct(kw[:__struct__])
 
     if left && Enum.all?(kw, fn {k, _} -> Map.has_key?(left, k) end) do
       if Macro.quoted_literal?(kw) do
@@ -674,7 +677,8 @@ defmodule ExUnit.Diff do
   end
 
   defp load_struct(struct) do
-    if Code.ensure_loaded?(struct) and function_exported?(struct, :__struct__, 0) do
+    if is_atom(struct) and struct != nil and
+         Code.ensure_loaded?(struct) and function_exported?(struct, :__struct__, 0) do
       struct.__struct__
     end
   end
@@ -761,11 +765,10 @@ defmodule ExUnit.Diff do
     String.bag_distance(left, right) > 0.4
   end
 
-  defp parse_string({:<>, _, [literal, rest]}) do
+  defp parse_string({:<>, _, [literal, rest]}) when is_binary(literal) do
     {parsed, quoted, indexes, parsed_length} = parse_string(rest)
     literal_length = String.length(literal)
     length = literal_length + parsed_length
-
     {literal <> parsed, quoted, [literal_length | indexes], length}
   end
 

lib/ex_unit/lib/ex_unit/formatter.ex

@@ -54,6 +54,7 @@ defmodule ExUnit.Formatter do
 
   @counter_padding "     "
   @mailbox_label_padding @counter_padding <> "  "
+  @formatter_exceptions [ExUnit.AssertionError, FunctionClauseError]
   @no_value ExUnit.AssertionError.no_value()
 
   @doc """
@@ -136,10 +137,10 @@ defmodule ExUnit.Formatter do
 
   @doc false
   def format_assertion_error(%ExUnit.AssertionError{} = struct) do
-    format_assertion_error(%{}, struct, [], :infinity, fn _, msg -> msg end, "")
+    format_exception(%{}, struct, [], :infinity, fn _, msg -> msg end, "") |> elem(0)
   end
 
-  defp format_assertion_error(test, struct, stack, width, formatter, counter_padding) do
+  defp format_exception(test, %ExUnit.AssertionError{} = struct, stack, width, formatter, pad) do
     label_padding_size = if has_value?(struct.right), do: 7, else: 6
     padding_size = label_padding_size + byte_size(@counter_padding)
 
@@ -148,16 +149,27 @@ defmodule ExUnit.Formatter do
         do: &pad_multiline(&1, padding_size),
         else: &code_multiline(&1, padding_size)
 
-    [
-      note: if_value(struct.message, &format_message(&1, formatter)),
-      doctest: if_value(struct.doctest, &pad_multiline(&1, 2 + byte_size(@counter_padding))),
-      code: if_value(struct.expr, code_multiline),
-      code: unless_value(struct.expr, fn -> get_code(test, stack) || @no_value end),
-      arguments: if_value(struct.args, &format_args(&1, width))
-    ]
-    |> Kernel.++(format_context(struct, formatter, padding_size, width))
-    |> format_meta(formatter, counter_padding, label_padding_size)
-    |> IO.iodata_to_binary()
+    formatted =
+      [
+        note: if_value(struct.message, &format_message(&1, formatter)),
+        doctest: if_value(struct.doctest, &pad_multiline(&1, 2 + byte_size(@counter_padding))),
+        code: if_value(struct.expr, code_multiline),
+        code: unless_value(struct.expr, fn -> get_code(test, stack) || @no_value end),
+        arguments: if_value(struct.args, &format_args(&1, width))
+      ]
+      |> Kernel.++(format_context(struct, formatter, padding_size, width))
+      |> format_meta(formatter, pad, label_padding_size)
+      |> IO.iodata_to_binary()
+
+    {formatted, stack}
+  end
+
+  defp format_exception(test, %FunctionClauseError{} = struct, stack, _width, formatter, _pad) do
+    {blamed, stack} = Exception.blame(:error, struct, stack)
+    banner = Exception.format_banner(:error, struct)
+    blamed = FunctionClauseError.blame(blamed, &inspect/1, &blame_match(&1, &2, formatter))
+    message = error_info(banner, formatter) <> "\n" <> pad(String.trim_leading(blamed, "\n"))
+    {message <> format_code(test, stack, formatter), stack}
   end
 
   @doc false
@@ -179,30 +191,48 @@ defmodule ExUnit.Formatter do
       end)
   end
 
-  defp format_kind_reason(
-         test,
-         :error,
-         %ExUnit.AssertionError{} = struct,
-         stack,
-         width,
-         formatter
-       ) do
-    {format_assertion_error(test, struct, stack, width, formatter, @counter_padding), stack}
+  defp format_kind_reason(test, :error, %mod{} = struct, stack, width, formatter)
+       when mod in @formatter_exceptions do
+    format_exception(test, struct, stack, width, formatter, @counter_padding)
   end
 
-  defp format_kind_reason(test, :error, %FunctionClauseError{} = struct, stack, _width, formatter) do
-    {blamed, stack} = Exception.blame(:error, struct, stack)
-    banner = Exception.format_banner(:error, struct)
-    blamed = FunctionClauseError.blame(blamed, &inspect/1, &blame_match(&1, &2, formatter))
-    message = error_info(banner, formatter) <> "\n" <> pad(String.trim_leading(blamed, "\n"))
-    {message <> format_code(test, stack, formatter), stack}
+  defp format_kind_reason(test, kind, reason, stack, width, formatter) do
+    case linked_or_trapped_exit(kind, reason) do
+      {header, wrapped_reason, wrapped_stack} ->
+        struct = Exception.normalize(:error, wrapped_reason, wrapped_stack)
+
+        {formatted_reason, _} =
+          format_exception(test, struct, wrapped_stack, width, formatter, @counter_padding)
+
+        formatted_stack = format_stacktrace(wrapped_stack, test.module, test.name, formatter)
+        {error_info(header, formatter) <> pad(formatted_reason <> formatted_stack), stack}
+
+      :error ->
+        {reason, stack} = Exception.blame(kind, reason, stack)
+        message = error_info(Exception.format_banner(kind, reason), formatter)
+        {message <> format_code(test, stack, formatter), stack}
+    end
   end
 
-  defp format_kind_reason(test, kind, reason, stack, _width, formatter) do
-    message = error_info(Exception.format_banner(kind, reason), formatter)
-    {message <> format_code(test, stack, formatter), stack}
+  defp linked_or_trapped_exit({:EXIT, pid}, {reason, [_ | _] = stack})
+       when :erlang.map_get(:__struct__, reason) in @formatter_exceptions
+       when reason == :function_clause do
+    {"** (EXIT from #{inspect(pid)}) an exception was raised:\n", reason, stack}
   end
 
+  defp linked_or_trapped_exit(:exit, {{reason, [_ | _] = stack}, {mod, fun, args}})
+       when is_atom(mod) and is_atom(fun) and is_list(args) and
+              :erlang.map_get(:__struct__, reason) in @formatter_exceptions
+       when is_atom(mod) and is_atom(fun) and is_list(args) and reason == :function_clause do
+    {
+      "** (exit) exited in: #{Exception.format_mfa(mod, fun, args)}\n   ** (EXIT) an exception was raised:",
+      reason,
+      stack
+    }
+  end
+
+  defp linked_or_trapped_exit(_kind, _reason), do: :error
+
   defp format_code(test, stack, formatter) do
     if snippet = get_code(test, stack) do
       "     " <> formatter.(:extra_info, "code: ") <> snippet <> "\n"
@@ -338,7 +368,7 @@ defmodule ExUnit.Formatter do
             {:match, pins},
             formatter,
             padding_size + 5,
-            width - 5
+            width
           )
 
         [

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -375,6 +375,7 @@ defmodule ExUnit.AssertionsTest do
 
         "assert_received({:status, ^status, ^status})" = Macro.to_string(error.expr)
         "{:status, ^status, ^status}" = Macro.to_string(error.left)
+        "\n\nAssertion failed" <> _ = Exception.message(error)
     end
   end
 

lib/ex_unit/test/ex_unit/diff_test.exs

@@ -141,6 +141,11 @@ defmodule ExUnit.DiffTest do
     refute_diff(^b = :a, "-^b-", "+:a+", pins)
   end
 
+  test "pseudo vars" do
+    assert_diff(__MODULE__ = ExUnit.DiffTest, [])
+    refute_diff(__MODULE__ = SomethingElse, "-__MODULE__-", "+SomethingElse+")
+  end
+
   test "integers" do
     assert_diff(123 = 123, [])
     assert_diff(-123 = -123, [])
@@ -471,6 +476,34 @@ defmodule ExUnit.DiffTest do
     refute_diff(%{a: 1} = :a, "-%{a: 1}-", "+:a+")
   end
 
+  test "maps as pinned map value" do
+    user = %{"id" => 13, "name" => "john"}
+
+    notification = %{
+      "user" => user,
+      "subtitle" => "foo"
+    }
+
+    assert_diff(
+      %{
+        "user" => ^user,
+        "subtitle" => "foo"
+      } = notification,
+      [],
+      %{{:user, nil} => user}
+    )
+
+    refute_diff(
+      %{
+        "user" => ^user,
+        "subtitle" => "bar"
+      } = notification,
+      ~s|%{"subtitle" => "-bar-", "user" => ^user}|,
+      ~s|%{"subtitle" => "+foo+", "user" => %{"id" => 13, "name" => "john"}}|,
+      %{{:user, nil} => user}
+    )
+  end
+
   test "maps outside match context" do
     assert_diff(%{a: 1} == %{a: 1}, [])
     assert_diff(%{a: 1, b: 2} == %{a: 1, b: 2}, [])
@@ -594,7 +627,7 @@ defmodule ExUnit.DiffTest do
     )
   end
 
-  test "structs with inspect difference" do
+  test "structs with same inspect but different" do
     refute_diff(
       %Opaque{data: 1} = %Opaque{data: 2},
       "%ExUnit.DiffTest.Opaque{data: -1-}",
@@ -608,7 +641,7 @@ defmodule ExUnit.DiffTest do
     )
   end
 
-  test "structs without inspect difference outside match" do
+  test "structs with same inspect but different outside match" do
     refute_diff(
       %Opaque{data: 1} == %Opaque{data: 2},
       "%ExUnit.DiffTest.Opaque{data: -1-}",
@@ -630,6 +663,66 @@ defmodule ExUnit.DiffTest do
     )
   end
 
+  test "structs with matched type" do
+    pins = %{{:type, nil} => User, {:age, nil} => 33}
+
+    # pin on __struct__
+    assert_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = %User{name: "john", age: 33},
+      [],
+      pins
+    )
+
+    refute_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = %User{name: "jane", age: 33},
+      "%{__struct__: ^type, age: ^age, name: \"j-oh-n\"}",
+      "%ExUnit.DiffTest.User{age: 33, name: \"j+a+n+e+\"}",
+      pins
+    )
+
+    refute_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = %User{name: "john", age: 35},
+      "%{__struct__: ^type, age: -^age-, name: \"john\"}",
+      "%ExUnit.DiffTest.User{age: 3+5+, name: \"john\"}",
+      pins
+    )
+
+    refute_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = ~D[2020-01-01],
+      "%{__struct__: -^type-, -age: ^age-, -name: \"john\"-}",
+      "%+Date+{calendar: Calendar.ISO, day: 1, month: 1, year: 2020}",
+      pins
+    )
+
+    # pin on %
+    assert_diff(
+      %^type{age: ^age, name: "john"} = %User{name: "john", age: 33},
+      [],
+      pins
+    )
+
+    refute_diff(
+      %^type{age: ^age, name: "john"} = %User{name: "jane", age: 33},
+      "%{__struct__: ^type, age: ^age, name: \"j-oh-n\"}",
+      "%ExUnit.DiffTest.User{age: 33, name: \"j+a+n+e+\"}",
+      pins
+    )
+
+    refute_diff(
+      %^type{age: ^age, name: "john"} = %User{name: "john", age: 35},
+      "%{__struct__: ^type, age: -^age-, name: \"john\"}",
+      "%ExUnit.DiffTest.User{age: 3+5+, name: \"john\"}",
+      pins
+    )
+
+    refute_diff(
+      %^type{age: ^age, name: "john"} = ~D[2020-01-01],
+      "%{__struct__: -^type-, -age: ^age-, -name: \"john\"-}",
+      "%+Date+{calendar: Calendar.ISO, day: 1, month: 1, year: 2020}",
+      pins
+    )
+  end
+
   test "invalid structs" do
     refute_diff(
       %{__struct__: Unknown} = %{},
@@ -721,7 +814,7 @@ defmodule ExUnit.DiffTest do
     )
   end
 
-  test "concat operator" do
+  test "concat binaries" do
     assert_diff("fox hops" <> " over the dog" = "fox hops over the dog", [])
     assert_diff("fox hops " <> "over " <> "the dog" = "fox hops over the dog", [])
 
@@ -755,6 +848,10 @@ defmodule ExUnit.DiffTest do
       ~s/"fox hops over the dog"/
     )
 
+    refute_diff("fox" <> " hops" = :a, ~s/-"fox" <> " hops"-/, "+:a+")
+  end
+
+  test "concat binaries with pin" do
     pins = %{{:x, nil} => " over the dog"}
 
     assert_diff("fox hops" <> x = "fox hops over the dog", x: " over the dog")
@@ -773,8 +870,16 @@ defmodule ExUnit.DiffTest do
       ~s/"fox hops over +t+he dog"/,
       pins
     )
+  end
 
-    refute_diff("fox" <> " hops" = :a, ~s/-"fox" <> " hops"-/, "+:a+")
+  test "concat binaries with specifiers" do
+    input = "foobar"
+
+    refute_diff(
+      <<trap::binary-size(3)>> <> "baz" = input,
+      "-<<trap::binary-size(3)>> <> \"baz\"-",
+      "+\"foobar\"+"
+    )
   end
 
   test "underscore" do
@@ -809,6 +914,7 @@ defmodule ExUnit.DiffTest do
     refute_diff((x when x == 1 or x == 2) = 0, "x when -x == 1- or -x == 2-", "0")
     refute_diff((x when x == 1 when x == 2) = 0, "x when -x == 1- when -x == 2-", "0")
     refute_diff((x when x in [1, 2]) = 0, "x when -x in [1, 2]-", "0")
+    refute_diff(({:ok, x} when x == 1) = :error, "-{:ok, x}- when x == 1", "+:error+")
   end
 
   test "charlists" do

lib/ex_unit/test/ex_unit/formatter_test.exs

@@ -69,6 +69,61 @@ defmodule ExUnit.FormatterTest do
            """
   end
 
+  test "formats test exits with function clause mfa" do
+    {error, stack} =
+      try do
+        Access.fetch(:foo, :bar)
+      catch
+        :error, error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{:exit, {{error, stack}, {:mod, :fun, []}}, []}]
+
+    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (exit) exited in: :mod.fun()
+                     ** (EXIT) an exception was raised:
+                       ** (FunctionClauseError) no function clause matching in Access.fetch/2
+
+                       The following arguments were given to Access.fetch/2:
+
+                           # 1
+                           :foo
+
+                           # 2
+                           :bar
+
+                       Attempted function clauses (showing 5 out of 5):
+
+                           def fetch(%module{} = container, key)
+             """
+  end
+
+  test "formats test exits with assertion mfa" do
+    {error, stack} =
+      try do
+        assert 1 == 2
+      rescue
+        error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{:exit, {{error, stack}, {:mod, :fun, []}}, []}]
+
+    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (exit) exited in: :mod.fun()
+                     ** (EXIT) an exception was raised:
+                       Assertion with == failed
+                       code:  assert 1 == 2
+                       left:  1
+                       right: 2
+             """
+  end
+
   test "formats test throws" do
     failure = [{:throw, 1, []}]
 
@@ -89,6 +144,61 @@ defmodule ExUnit.FormatterTest do
            """
   end
 
+  test "formats test EXITs with function clause errors" do
+    {error, stack} =
+      try do
+        Access.fetch(:foo, :bar)
+      catch
+        :error, error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{{:EXIT, self()}, {error, stack}, []}]
+
+    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (EXIT from #{inspect(self())}) an exception was raised:
+
+                       ** (FunctionClauseError) no function clause matching in Access.fetch/2
+
+                       The following arguments were given to Access.fetch/2:
+
+                           # 1
+                           :foo
+
+                           # 2
+                           :bar
+
+                       Attempted function clauses (showing 5 out of 5):
+
+                           def fetch(%module{} = container, key)
+             """
+  end
+
+  test "formats test EXITs with assertion errors" do
+    {error, stack} =
+      try do
+        assert 1 == 2
+      rescue
+        error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{{:EXIT, self()}, {error, stack}, []}]
+
+    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (EXIT from #{inspect(self())}) an exception was raised:
+
+                       Assertion with == failed
+                       code:  assert 1 == 2
+                       left:  1
+                       right: 2
+             """
+  end
+
   test "formats test errors with test_location_relative_path" do
     Application.put_env(:ex_unit, :test_location_relative_path, "apps/sample")
     failure = [{:error, catch_error(raise "oops"), []}]

lib/iex/lib/iex/introspection.ex

@@ -735,9 +735,15 @@ defmodule IEx.Introspection do
   ## Helpers
 
   defp format_typespec(definition, kind, nesting) do
-    "@#{kind} #{Macro.to_string(definition)}"
-    |> Code.format_string!(line_length: IEx.width() - 2 * nesting)
-    |> IO.iodata_to_binary()
+    string = "@#{kind} #{Macro.to_string(definition)}"
+
+    try do
+      string
+      |> Code.format_string!(line_length: IEx.width() - 2 * nesting)
+      |> IO.iodata_to_binary()
+    rescue
+      _ -> string
+    end
     |> color_prefix_with_line()
     |> indent(nesting)
   end

lib/iex/test/iex/helpers_test.exs

@@ -382,7 +382,7 @@ defmodule IEx.HelpersTest do
         "* def left == right\n\n  @spec term() == term() :: boolean()\n\nguard: true\n\nReturns `true` if the two terms are equal.\n\n"
 
       def_h =
-        "* defmacro def(call, expr \\\\ [])\n\nDefines a public function with the given name and body."
+        "* defmacro def(call, expr \\\\ nil)\n\nDefines a public function with the given name and body."
 
       assert capture_io(fn -> h(IEx.Helpers.pwd() / 0) end) =~ pwd_h
       assert capture_io(fn -> h(IEx.Helpers.c() / 2) end) =~ c_h
@@ -853,6 +853,7 @@ defmodule IEx.HelpersTest do
       defmodule TypeSample do
         @typedoc "An ID with description."
         @type id_with_desc :: {number, String.t}
+        @type unquote(:"?")() :: :question_mark
       end
       """
 
@@ -872,6 +873,11 @@ defmodule IEx.HelpersTest do
 
                An ID with description.
                """
+
+        assert capture_io(fn -> t(TypeSample."?"()) end) == """
+               @type ?() :: :question_mark
+
+               """
       end)
     after
       cleanup_modules([TypeSample])

lib/logger/lib/logger.ex

@@ -467,8 +467,9 @@ defmodule Logger do
 
   Erlang/OTP handlers must be listed under your own application:
 
-      config :my_app, :logger,
-        [:handler, :name_of_the_handler, ACustomHandler, configuration = %{}]
+      config :my_app, :logger, [
+        {:handler, :name_of_the_handler, ACustomHandler, configuration = %{}}
+      ]
 
   And then explicitly attached in your `c:Application.start/2` callback:
 

lib/logger/lib/logger/config.ex

@@ -32,14 +32,6 @@ defmodule Logger.Config do
      Application.fetch_env!(:logger, :discard_threshold_periodic_check)}
   end
 
-  def handle_event({_type, gl, _msg} = event, state) when node(gl) != node() do
-    # Cross node messages are always async which also
-    # means this handler won't crash in case Logger
-    # is not installed in the other node.
-    :gen_event.notify({Logger, node(gl)}, event)
-    {:ok, update_counter(state, false)}
-  end
-
   def handle_event(_event, state) do
     {:ok, update_counter(state, false)}
   end

lib/logger/lib/logger/formatter.ex

@@ -168,22 +168,42 @@ defmodule Logger.Formatter do
   defp levelpad(:warn), do: " "
   defp levelpad(:error), do: ""
 
-  defp metadata([{:report_cb, _} | metadata]), do: metadata(metadata)
-  defp metadata([{:time, _} | metadata]), do: metadata(metadata)
-  defp metadata([{:gl, _} | metadata]), do: metadata(metadata)
-  defp metadata([{:crash_reason, _} | metadata]), do: metadata(metadata)
-  defp metadata([{:ancestors, _} | metadata]), do: metadata(metadata)
-  defp metadata([{:callers, _} | metadata]), do: metadata(metadata)
-  defp metadata([{_, nil} | metadata]), do: metadata(metadata)
-
   defp metadata([{key, value} | metadata]) do
-    [to_string(key), ?=, metadata(key, value), ?\s | metadata(metadata)]
+    if formatted = metadata(key, value) do
+      [to_string(key), ?=, formatted, ?\s | metadata(metadata)]
+    else
+      metadata(metadata)
+    end
   end
 
   defp metadata([]) do
     []
   end
 
+  defp metadata(:time, _), do: nil
+  defp metadata(:gl, _), do: nil
+
+  defp metadata(_, nil), do: nil
+  defp metadata(_, string) when is_binary(string), do: string
+  defp metadata(_, integer) when is_integer(integer), do: Integer.to_string(integer)
+  defp metadata(_, float) when is_float(float), do: Float.to_string(float)
+  defp metadata(_, pid) when is_pid(pid), do: :erlang.pid_to_list(pid)
+
+  defp metadata(_, atom) when is_atom(atom) do
+    case Atom.to_string(atom) do
+      "Elixir." <> rest -> rest
+      "nil" -> ""
+      binary -> binary
+    end
+  end
+
+  defp metadata(_, ref) when is_reference(ref) do
+    '#Ref' ++ rest = :erlang.ref_to_list(ref)
+    rest
+  end
+
+  defp metadata(:file, file) when is_list(file), do: file
+
   defp metadata(:domain, [head | tail]) when is_atom(head) do
     Enum.map_intersperse([head | tail], ?., &Atom.to_string/1)
   end
@@ -198,22 +218,5 @@ defmodule Logger.Formatter do
     Exception.format_mfa(mod, fun, arity)
   end
 
-  defp metadata(_, pid) when is_pid(pid) do
-    :erlang.pid_to_list(pid)
-  end
-
-  defp metadata(_, ref) when is_reference(ref) do
-    '#Ref' ++ rest = :erlang.ref_to_list(ref)
-    rest
-  end
-
-  defp metadata(_, atom) when is_atom(atom) do
-    case Atom.to_string(atom) do
-      "Elixir." <> rest -> rest
-      "nil" -> ""
-      binary -> binary
-    end
-  end
-
-  defp metadata(_, other), do: to_string(other)
+  defp metadata(_, _), do: nil
 end

lib/logger/lib/logger/handler.ex

@@ -230,7 +230,7 @@ defmodule Logger.Handler do
     translate_fallback(:format, callback.(data), meta, truncate)
   end
 
-  defp translate_fallback(:report, {:logger, data}, %{report_cb: callback} = meta, truncate)
+  defp translate_fallback(:report, {:logger, data}, %{report_cb: callback}, _truncate)
        when is_function(callback, 2) do
     translator_opts =
       struct(Inspect.Opts, Application.fetch_env!(:logger, :translator_inspect_opts))
@@ -241,7 +241,7 @@ defmodule Logger.Handler do
       single_line: false
     }
 
-    translate_fallback(:format, callback.(data, opts), meta, truncate)
+    callback.(data, opts)
   end
 
   defp translate_fallback(:format, {format, args}, _meta, truncate) do

lib/logger/lib/logger/utils.ex

@@ -81,7 +81,7 @@ defmodule Logger.Utils do
   end
 
   defp fix_binary(<<h, t::binary>>, acc) do
-    fix_binary(t, <<h, acc::binary>>)
+    fix_binary(t, <<acc::binary, h>>)
   end
 
   defp fix_binary(<<>>, _acc) do

lib/logger/test/logger/formatter_test.exs

@@ -77,9 +77,9 @@ defmodule Logger.FormatterTest do
              "2014-12-30 12:06:30.100"
   end
 
-  test "format discards callers/ancestors/crash_reason" do
+  test "format discards unknown formats" do
     compiled = compile("$metadata $message")
-    metadata = [callers: :discard, ancestors: :discard, crash_reason: :discard, foo: :bar]
+    metadata = [ancestors: [self()], crash_reason: {:some, :tuple}, foo: :bar]
 
     assert format(compiled, :error, "hello", nil, metadata) ==
              [["foo", 61, "bar", 32], " ", "hello"]

lib/logger/test/logger/handler_test.exs

@@ -147,6 +147,6 @@ defmodule Logger.HandlerTest do
   defp format_report(report, opts) do
     send(self(), {:format, report, opts})
 
-    {'~p', [report]}
+    inspect(report)
   end
 end

lib/logger/test/logger/translator_test.exs

@@ -306,13 +306,14 @@ defmodule Logger.TranslatorTest do
 
   test "translates Task crashes" do
     {:ok, pid} = Task.start_link(__MODULE__, :task, [self()])
+    parent = self()
 
     assert capture_log(fn ->
              ref = Process.monitor(pid)
              send(pid, :go)
              receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
            end) =~ ~r"""
-           \[error\] Task #PID<\d+\.\d+\.\d+> started from #PID<\d+\.\d+\.\d+> terminating
+           \[error\] Task #{inspect(pid)} started from #{inspect(self())} terminating
            \*\* \(RuntimeError\) oops
            .*
            Function: &Logger.TranslatorTest.task\/1
@@ -324,6 +325,7 @@ defmodule Logger.TranslatorTest do
 
     assert {%RuntimeError{message: "oops"}, [_ | _]} = task_metadata[:crash_reason]
     assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+    assert [parent] == task_metadata[:callers]
 
     refute Keyword.has_key?(task_metadata, :initial_call)
     assert process_metadata[:initial_call] == {Logger.TranslatorTest, :task, 1}
@@ -332,6 +334,7 @@ defmodule Logger.TranslatorTest do
   test "translates Task async_stream crashes with neighbour" do
     fun = fn -> Task.async_stream([:oops], :erlang, :error, []) |> Enum.to_list() end
     {:ok, pid} = Task.start(__MODULE__, :task, [self(), fun])
+    parent = self()
 
     assert capture_log(:debug, fn ->
              ref = Process.monitor(pid)
@@ -345,12 +348,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [pid, parent] == task_metadata[:callers]
 
     assert {:oops, [_ | _]} = task_metadata[:crash_reason]
     assert {%ErlangError{original: :oops}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task undef module crash" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(:module_does_not_exist, :undef, [])
              ref = Process.monitor(pid)
@@ -365,12 +371,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task undef function crash" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(__MODULE__, :undef, [])
              ref = Process.monitor(pid)
@@ -385,12 +394,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task raising ErlangError" do
+    parent = self()
+
     assert capture_log(fn ->
              exception =
                try do
@@ -413,12 +425,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%ErlangError{original: :foo}, [_ | _]} = task_metadata[:crash_reason]
     assert {%ErlangError{original: :foo}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task raising Erlang badarg error" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(:erlang, :error, [:badarg])
              ref = Process.monitor(pid)
@@ -433,12 +448,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%ArgumentError{message: "argument error"}, [_ | _]} = task_metadata[:crash_reason]
     assert {%ArgumentError{message: "argument error"}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task exiting abnormally" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(:erlang, :exit, [:abnormal])
              ref = Process.monitor(pid)
@@ -453,6 +471,7 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {:abnormal, [_ | _]} = task_metadata[:crash_reason]
     assert {:abnormal, [_ | _]} = process_metadata[:crash_reason]
@@ -625,8 +644,9 @@ defmodule Logger.TranslatorTest do
            """
   end
 
-  test "translates :proc_lib crashes on debug" do
+  test "translates :proc_lib+Task crashes on debug" do
     {:ok, pid} = Task.start_link(__MODULE__, :task, [self()])
+    parent = self()
 
     assert capture_log(:debug, fn ->
              ref = Process.monitor(pid)
@@ -652,13 +672,15 @@ defmodule Logger.TranslatorTest do
     assert process_metadata[:pid] == task_metadata[:pid]
     assert is_list(process_metadata[:callers])
     assert is_list(process_metadata[:ancestors])
+    assert [parent] == task_metadata[:callers]
 
     assert {%RuntimeError{message: "oops"}, [_ | _]} = task_metadata[:crash_reason]
     assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
   end
 
-  test "translates :proc_lib crashes with neighbour on debug" do
+  test "translates :proc_lib+Task crashes with neighbour on debug" do
     {:ok, pid} = Task.start_link(__MODULE__, :sub_task, [self()])
+    parent = self()
 
     assert capture_log(:debug, fn ->
              ref = Process.monitor(pid)
@@ -677,6 +699,9 @@ defmodule Logger.TranslatorTest do
                    Current Stacktrace:
                        (lib/logger/)?test/logger/translator_test.exs:\d+: Logger.TranslatorTest.sleep/1
            """
+
+    assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
+    assert [parent] == task_metadata[:callers]
   end
 
   test "translates Supervisor progress" do

lib/logger/test/logger/utils_test.exs

@@ -23,6 +23,7 @@ defmodule Logger.UtilsTest do
     assert truncate("olá", 4) == "olá"
     assert truncate("ááááá:", 10) == ["ááááá", " (truncated)"]
     assert truncate("áááááá:", 10) == ["ááááá", " (truncated)"]
+    assert truncate("𠜎𠜱𠝹𠱓", 15) == ["𠜎𠜱𠝹", " (truncated)"]
 
     # Charlists
     assert truncate('olá', 2) == ['olá', " (truncated)"]

lib/mix/lib/mix/dep.ex

@@ -66,7 +66,7 @@ defmodule Mix.Dep do
           scm: Mix.SCM.t(),
           app: atom,
           requirement: String.t() | Regex.t() | nil,
-          status: atom,
+          status: {:ok, String.t() | nil} | atom | tuple,
           opts: keyword,
           top_level: boolean,
           manager: :rebar | :rebar3 | :mix | :make | nil,

lib/mix/lib/mix/dep/fetcher.ex

@@ -65,6 +65,7 @@ defmodule Mix.Dep.Fetcher do
           end
 
         if new do
+          File.touch!(Path.join(opts[:dest], ".fetch"))
           dep = put_in(dep.opts[:lock], new)
           {dep, [app | acc], Map.put(lock, app, new)}
         else
@@ -92,22 +93,18 @@ defmodule Mix.Dep.Fetcher do
     # dependency is missing, it could directly affect one of the
     # dependencies we are trying to compile, causing the whole thing
     # to fail.
-    #
-    # If there is any other dependency that is not ok, we include
-    # it for compilation too, this is our best to try to solve the
-    # maximum we can at each deps.get and deps.update.
-    deps =
+    parent_deps =
       if Enum.all?(all_deps, &available?/1) do
         Enum.uniq_by(with_depending(deps, all_deps), & &1.app)
       else
-        deps
+        []
       end
 
     # Merge the new lock on top of the old to guarantee we don't
     # leave out things that could not be fetched and save it.
     lock = Map.merge(old_lock, new_lock)
     Mix.Dep.Lock.write(lock)
-    mark_as_fetched(deps)
+    mark_as_fetched(parent_deps)
 
     # See if any of the deps diverged and abort.
     show_diverged!(Enum.filter(all_deps, &Mix.Dep.diverged?/1))

lib/mix/lib/mix/local.ex

@@ -161,14 +161,29 @@ defmodule Mix.Local do
         contents
 
       {:remote, message} ->
-        Mix.raise("""
-        #{message}
+        Mix.raise(
+          """
+          #{message}
 
-        Could not install #{name} because Mix could not download metadata at #{path}.
-        """)
+          Could not install #{name} because Mix could not download metadata at #{path}.
+          """ <> suggestions(name)
+        )
     end
   end
 
+  defp suggestions("Hex") do
+    """
+
+    Alternatively, you can compile and install Hex directly with this command:
+
+        mix archive.install github hexpm/hex branch latest
+    """
+  end
+
+  defp suggestions(_) do
+    ""
+  end
+
   defp parse_csv(body) do
     body
     |> :binary.split("\n", [:global, :trim])

lib/mix/lib/mix/release.ex

@@ -402,7 +402,7 @@ defmodule Mix.Release do
     args = [runtime_config?, sys_config]
     format = "%% coding: utf-8~n%% RUNTIME_CONFIG=~s~n~tw.~n"
     File.mkdir_p!(Path.dirname(path))
-    File.write!(path, :io_lib.format(format, args), [:utf8])
+    File.write!(path, IO.chardata_to_string(:io_lib.format(format, args)))
 
     case :file.consult(path) do
       {:ok, _} ->
@@ -425,13 +425,29 @@ defmodule Mix.Release do
     opts = [
       extra_config: initial_config,
       prune_after_boot: prune_after_boot,
-      reboot_after_config: reboot?
+      reboot_after_config: reboot?,
+      validate_compile_env: validate_compile_env(release)
     ]
 
     init = Config.Provider.init(release.config_providers, config_path, opts)
     {Config.Reader.merge(sys_config, [elixir: [config_providers: init]] ++ extra_config), reboot?}
   end
 
+  defp validate_compile_env(release) do
+    with true <- Keyword.get(release.options, :validate_compile_env, true),
+         [_ | _] = compile_env <- compile_env(release) do
+      compile_env
+    else
+      _ -> false
+    end
+  end
+
+  defp compile_env(release) do
+    for {_, properties} <- release.applications,
+        triplet <- Keyword.get(properties, :compile_env, []),
+        do: triplet
+  end
+
   defp start_distribution(%{options: opts}) do
     reboot? = Keyword.get(opts, :reboot_system_after_config, true)
     early_distribution? = Keyword.get(opts, :start_distribution_during_config, false)
@@ -496,7 +512,7 @@ defmodule Mix.Release do
           :ok | {:error, String.t()}
   def make_boot_script(release, path, modes, prepend_paths \\ []) do
     with {:ok, rel_spec} <- build_release_spec(release, modes) do
-      File.write!(path <> ".rel", consultable(rel_spec), [:utf8])
+      File.write!(path <> ".rel", consultable(rel_spec))
 
       sys_path = String.to_charlist(path)
 
@@ -519,7 +535,7 @@ defmodule Mix.Release do
             |> prepend_paths_to_script(prepend_paths)
 
           script = {:script, rel_info, instructions}
-          File.write!(script_path, consultable(script), [:utf8])
+          File.write!(script_path, consultable(script))
           :ok = :systools.script2boot(sys_path)
 
         {:error, module, info} ->
@@ -613,8 +629,7 @@ defmodule Mix.Release do
         &(not match?({:apply, {:application, :start_boot, [:stdlib, _]}}, &1))
       )
 
-    pre ++
-      [stdlib] ++ config_provider_apply(release) ++ validate_compile_env_apply(release) ++ post
+    pre ++ [stdlib] ++ config_provider_apply(release) ++ post
   end
 
   defp config_provider_apply(%{config_providers: []}),
@@ -623,21 +638,6 @@ defmodule Mix.Release do
   defp config_provider_apply(_),
     do: [{:apply, {Config.Provider, :boot, [:elixir, :config_providers]}}]
 
-  defp validate_compile_env_apply(release) do
-    with true <- Keyword.get(release.options, :validate_compile_env, true),
-         [_ | _] = compile_env <- compile_env(release) do
-      [{:apply, {Config.Provider, :validate_compile_env, [compile_env]}}]
-    else
-      _ -> []
-    end
-  end
-
-  defp compile_env(release) do
-    for {_, properties} <- release.applications,
-        triplet <- Keyword.get(properties, :compile_env, []),
-        do: triplet
-  end
-
   defp prepend_paths_to_script(instructions, []), do: instructions
 
   defp prepend_paths_to_script(instructions, prepend_paths) do
@@ -657,7 +657,7 @@ defmodule Mix.Release do
   end
 
   defp consultable(term) do
-    :io_lib.format("%% coding: utf-8~n~tp.~n", [term])
+    IO.chardata_to_string(:io_lib.format("%% coding: utf-8~n~tp.~n", [term]))
   end
 
   @doc """

lib/mix/lib/mix/shell.ex

@@ -76,8 +76,12 @@ defmodule Mix.Shell do
 
   ## Options
 
+    * `:cd` - (since v1.11.0) the directory to run the command in
+
     * `:stderr_to_stdout` - redirects stderr to stdout, defaults to true
+
     * `:env` - a list of environment variables, defaults to `[]`
+
     * `:quiet` - overrides the callback to no-op
 
   """
@@ -98,7 +102,10 @@ defmodule Mix.Shell do
         []
       end
 
-    opts = [:stream, :binary, :exit_status, :hide, :use_stdio, {:env, env} | args]
+    opts =
+      [:stream, :binary, :exit_status, :hide, :use_stdio, {:env, env}] ++
+        args ++ Keyword.take(options, [:cd])
+
     port = Port.open({:spawn, shell_command(command)}, opts)
     port_read(port, callback)
   end

lib/mix/lib/mix/tasks/app.start.ex

@@ -162,8 +162,8 @@ defmodule Mix.Tasks.App.Start do
             {:error, {:file.format_error(:enoent), name}}
 
           path ->
-            case :file.consult(path) do
-              {:ok, [{:application, _, properties} = application_data]} ->
+            case consult_app_file_maybe_in_archive(path) do
+              {:ok, {:application, _, properties} = application_data} ->
                 with :ok <- :application.load(application_data) do
                   if compile_env = validate_compile_env? && properties[:compile_env] do
                     # Unfortunately we can only check the current app here,
@@ -182,6 +182,19 @@ defmodule Mix.Tasks.App.Start do
     end
   end
 
+  defp consult_app_file_maybe_in_archive(path) do
+    # The path could be located in .ez archive
+    case :erl_prim_loader.get_file(path) do
+      {:ok, bin, _full_name} ->
+        with {:ok, tokens, _} <- :erl_scan.string(String.to_charlist(bin)) do
+          :erl_parse.parse_term(tokens)
+        end
+
+      :error ->
+        {:error, :enoent}
+    end
+  end
+
   @doc false
   def type(config, opts) do
     cond do

lib/mix/lib/mix/tasks/cmd.ex

@@ -22,6 +22,13 @@ defmodule Mix.Tasks.Cmd do
   This task is automatically reenabled, so it can be called multiple times
   with different arguments.
 
+  ## Command line options
+
+    * `--app` - limit running the command to the given app. This option
+      may be given multiple times
+
+    * `--cd` - (since v1.11.0) the directory to run the command in
+
   ## Zombie operating system processes
 
   Beware that the Erlang VM does not terminate child processes
@@ -35,12 +42,20 @@ defmodule Mix.Tasks.Cmd do
   of the `Port` module documentation.
   """
 
+  @switches [
+    app: :keep,
+    cd: :string
+  ]
+
   @impl true
   def run(args) do
-    {args, apps} = parse_apps(args, [])
+    {opts, args} = OptionParser.parse_head!(args, strict: @switches)
+    apps = Enum.map(List.wrap(opts[:app]), &String.to_atom/1)
 
     if apps == [] or Mix.Project.config()[:app] in apps do
-      case Mix.shell().cmd(Enum.join(args, " ")) do
+      cmd_opts = Keyword.take(opts, [:cd])
+
+      case Mix.shell().cmd(Enum.join(args, " "), cmd_opts) do
         0 -> :ok
         status -> exit(status)
       end
@@ -48,14 +63,4 @@ defmodule Mix.Tasks.Cmd do
 
     Mix.Task.reenable("cmd")
   end
-
-  defp parse_apps(args, apps) do
-    case args do
-      ["--app", app | tail] ->
-        parse_apps(tail, [String.to_atom(app) | apps])
-
-      args ->
-        {args, apps}
-    end
-  end
 end

lib/mix/lib/mix/tasks/local.hex.ex

@@ -11,6 +11,11 @@ defmodule Mix.Tasks.Local.Hex do
 
       mix local.hex
 
+  If installing a precompiled Hex does not work, you can compile and install
+  Hex directly with this command:
+
+      mix archive.install github hexpm/hex branch latest
+
   ## Command line options
 
     * `--force` - forces installation without a shell prompt; primarily

lib/mix/lib/mix/tasks/release.ex

@@ -481,7 +481,9 @@ defmodule Mix.Tasks.Release do
   will receive a `Mix.Release` struct and must return the same or
   an updated `Mix.Release` struct. It is also possible to build a tarball
   of the release by passing the `:tar` step anywhere after `:assemble`.
-  The tarball is created in `_build/MIX_ENV/RELEASE_NAME-RELEASE_VSN.tar.gz`
+  If the release `:path` is not configured, the tarball is created in
+  `_build/MIX_ENV/RELEASE_NAME-RELEASE_VSN.tar.gz` Otherwise it is
+  created inside the configured `:path`.
 
   See `Mix.Release` for more documentation on the struct and which
   fields can be modified. Note that `:steps` field itself can be
@@ -1065,8 +1067,16 @@ defmodule Mix.Tasks.Release do
   end
 
   defp make_tar(release) do
-    tar_filename = "#{release.name}-#{release.version}.tar.gz"
-    out_path = Path.join([release.path, "..", "..", tar_filename]) |> Path.expand()
+    build_path = Mix.Project.build_path()
+
+    dir_path =
+      if release.path == Path.join([build_path, "rel", Atom.to_string(release.name)]) do
+        build_path
+      else
+        release.path
+      end
+
+    out_path = Path.join(dir_path, "#{release.name}-#{release.version}.tar.gz")
     info(release, [:green, "* building ", :reset, out_path])
 
     lib_dirs =

lib/mix/lib/mix/tasks/release.init.ex

@@ -416,9 +416,9 @@ defmodule Mix.Tasks.Release.Init do
       goto end
     )
 
-    !ERLSRV! add !RELEASE_NAME!_!RELEASE_NAME! ^
+    "!ERLSRV!" add "!RELEASE_NAME!_!RELEASE_NAME!" ^
       -!RELEASE_DISTRIBUTION! "!RELEASE_NODE!" ^
-      -env RELEASE_ROOT=!RELEASE_ROOT! -env RELEASE_NAME=!RELEASE_NAME! -env RELEASE_VSN=!RELEASE_VSN! -env RELEASE_COOKIE=!RELEASE_COOKIE! -env RELEASE_NODE=!RELEASE_NODE! -env RELEASE_VM_ARGS=!RELEASE_VM_ARGS! -env RELEASE_TMP=!RELEASE_TMP! -env RELEASE_SYS_CONFIG=!RELEASE_SYS_CONFIG! ^
+      -env RELEASE_ROOT="!RELEASE_ROOT!" -env RELEASE_NAME="!RELEASE_NAME!" -env RELEASE_VSN="!RELEASE_VSN!" -env RELEASE_COOKIE="!RELEASE_COOKIE!" -env RELEASE_NODE="!RELEASE_NODE!" -env RELEASE_VM_ARGS="!RELEASE_VM_ARGS!" -env RELEASE_TMP="!RELEASE_TMP!" -env RELEASE_SYS_CONFIG="!RELEASE_SYS_CONFIG!" ^
       -args "-setcookie !RELEASE_COOKIE! -config !RELEASE_SYS_CONFIG! -mode !RELEASE_MODE! -boot !REL_VSN_DIR!\start -boot_var RELEASE_LIB !RELEASE_ROOT!\lib -args_file !REL_VSN_DIR!\vm.args"
 
     if %ERRORLEVEL% EQU 0 (

lib/mix/test/fixtures/release_test/config/config.exs

@@ -1,4 +1,4 @@
 import Config
 
 config :release_test, :static, :was_set
-config :release_test, :encoding, {:"£", "£", '£'}
+config :release_test, :encoding, {:time_μs, :"£", "£", '£'}

lib/mix/test/mix/release_test.exs

@@ -488,11 +488,15 @@ defmodule Mix.ReleaseTest do
     end
 
     test "writes sys_config with encoding" do
-      assert make_sys_config(release([]), [encoding: {:"£", "£", '£'}], "unused/runtime/path") ==
+      assert make_sys_config(
+               release([]),
+               [encoding: {:time_μs, :"£", "£", '£'}],
+               "unused/runtime/path"
+             ) ==
                :ok
 
       {:ok, contents} = :file.consult(@sys_config)
-      assert contents == [[encoding: {:"£", "£", '£'}]]
+      assert contents == [[encoding: {:time_μs, :"£", "£", '£'}]]
     end
 
     test "writes the given sys_config with config providers" do

lib/mix/test/mix/shell_test.exs

@@ -17,4 +17,16 @@ defmodule Mix.ShellTest do
   after
     Mix.shell(Mix.Shell.Process)
   end
+
+  test "with :cd" do
+    Mix.shell(Mix.Shell.IO)
+    tmp_dir = System.tmp_dir()
+    {pwd, 0} = System.cmd("pwd", [], cd: tmp_dir)
+
+    assert ExUnit.CaptureIO.capture_io(fn ->
+             Mix.shell().cmd("pwd", cd: tmp_dir)
+           end) == pwd
+  after
+    Mix.shell(Mix.Shell.Process)
+  end
 end

lib/mix/test/mix/tasks/cmd_test.exs

@@ -36,4 +36,16 @@ defmodule Mix.Tasks.CmdTest do
       end)
     end)
   end
+
+  test "only runs the cmd for specified apps and in specific directory" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("cmd", ["--app", "bar", "--cd", "lib", "pwd"])
+        assert_received {:mix_shell, :info, ["==> bar"]}
+        {pwd, 0} = System.cmd("pwd", [], cd: Path.join(["apps", "bar", "lib"]))
+        assert_received {:mix_shell, :run, [^pwd]}
+        refute_received {:mix_shell, :info, ["==> foo"]}
+      end)
+    end)
+  end
 end

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

@@ -201,6 +201,32 @@ defmodule Mix.Tasks.Compile.ElixirTest do
     end)
   end
 
+  test "compiles dependent changed modules without beam files" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def a, do: A.__info__(:module)
+      end
+      """)
+
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.B.beam")
+
+      Code.put_compiler_option(:ignore_module_conflict, true)
+      Code.compile_file("lib/b.ex")
+      File.touch!("lib/a.ex", {{2038, 1, 1}, {0, 0, 0}})
+
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  after
+    Code.put_compiler_option(:ignore_module_conflict, false)
+  end
+
   test "compiles dependent changed modules even on removal" do
     in_fixture("no_mixfile", fn ->
       File.write!("lib/a.ex", "defmodule A, do: B.module_info()")

lib/mix/test/mix/tasks/compile_test.exs

@@ -146,6 +146,39 @@ defmodule Mix.Tasks.CompileTest do
     end)
   end
 
+  test "calling raise inside a macro returns a diagnostic with a position" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defmacro custom_macro do
+          raise "error"
+        end
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        require A
+        A.custom_macro()
+      end
+      """)
+
+      file = Path.absname("lib/b.ex")
+
+      ExUnit.CaptureIO.capture_io(fn ->
+        assert {:error, [diagnostic]} = Mix.Task.run("compile", ["--return-errors"])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 file: ^file,
+                 severity: :error,
+                 position: 3,
+                 message: "** (RuntimeError) error\n    expanding macro: A.custom_macro/0" <> _,
+                 compiler_name: "Elixir"
+               } = diagnostic
+      end)
+    end)
+  end
+
   test "returns syntax error from an Erlang file when --return-errors is set" do
     in_fixture("no_mixfile", fn ->
       import ExUnit.CaptureIO

lib/mix/test/mix/tasks/release_test.exs

@@ -135,7 +135,7 @@ defmodule Mix.Tasks.ReleaseTest do
   end
 
   describe "tar" do
-    test "with ERTS" do
+    test "with default options" do
       in_fixture("release_test", fn ->
         config = [releases: [demo: [steps: [:assemble, :tar]]]]
 
@@ -186,15 +186,15 @@ defmodule Mix.Tasks.ReleaseTest do
       end)
     end
 
-    test "without ERTS" do
+    test "without ERTS and custom path" do
       in_fixture("release_test", fn ->
-        config = [releases: [demo: [include_erts: false, steps: [:assemble, :tar]]]]
+        config = [
+          releases: [demo: [include_erts: false, path: "tmp/rel", steps: [:assemble, :tar]]]
+        ]
 
         Mix.Project.in_project(:release_test, ".", config, fn _ ->
-          root = Path.absname("_build/#{Mix.env()}/rel/demo")
-
           Mix.Task.run("release")
-          tar_path = Path.expand(Path.join([root, "..", "..", "demo-0.1.0.tar.gz"]))
+          tar_path = Path.expand(Path.join(["tmp", "rel", "demo-0.1.0.tar.gz"]))
           message = "* building #{tar_path}"
           assert_received {:mix_shell, :info, [^message]}
           assert File.exists?(tar_path)
@@ -281,7 +281,7 @@ defmodule Mix.Tasks.ReleaseTest do
         assert %{
                  app_dir: app_dir,
                  cookie_env: ^cookie,
-                 encoding: {:"£", "£", '£'},
+                 encoding: {:time_μs, :"£", "£", '£'},
                  mode: :embedded,
                  node: release_node("release_test"),
                  protocols_consolidated?: true,
@@ -322,7 +322,7 @@ defmodule Mix.Tasks.ReleaseTest do
         File.write!("config/releases.exs", """
         import Config
         config :release_test, :runtime, :was_set
-        config :release_test, :encoding, {:runtime, :"£", "£", '£'}
+        config :release_test, :encoding, {:runtime, :time_μs, :"£", "£", '£'}
         """)
 
         root = Path.absname("_build/dev/rel/runtime_config")
@@ -348,7 +348,7 @@ defmodule Mix.Tasks.ReleaseTest do
         open_port(Path.join(root, "bin/runtime_config"), ['start'])
 
         assert %{
-                 encoding: {:runtime, :"£", "£", '£'},
+                 encoding: {:runtime, :time_μs, :"£", "£", '£'},
                  mode: :embedded,
                  node: release_node("runtime_config"),
                  protocols_consolidated?: true,
@@ -514,7 +514,18 @@ defmodule Mix.Tasks.ReleaseTest do
     in_fixture("release_test", fn ->
       config = [releases: [permanent1: [include_erts: false]]]
 
+      # We write the compile env to guarantee rpc still works
+      File.write!("lib/compile_env.ex", """
+      _ = Application.compile_env(:release_test, :static)
+      """)
+
       Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        Mix.Task.run("loadconfig", [])
+
+        File.write!("config/releases.exs", """
+        import Config
+        """)
+
         root = Path.absname("_build/dev/rel/permanent1")
         Mix.Task.run("release")
         script = Path.join(root, "bin/permanent1")