Release v1.10.1

Unpack extra guards from with matches, closes #9801
fix(logger): use correct return value from report_cb/2 (#9798 )
2020-02-10 12:42:26 +01:00 · 2020-02-09 18:15:43 +01:00 · 2020-02-09 09:35:02 +01:00 · 2020-02-09 09:32:40 +01:00 · 2020-02-08 08:31:09 +01:00 · 2020-02-08 01:58:44 +01:00
57 changed files with 802 additions and 412 deletions
@@ -26,73 +26,163 @@ See the full CHANGELOG for more improvements.

 ## Improvements to sort-based APIs in Enum

-`Enum.sort/1` in Elixir always sorts from lowest to highest. If you want to sort from highest to lowest, you need to call `Enum.sort/2` with a custom sorting function, such as `Enum.sort(collection, &>=/2)`, which is not immediately obvious to someone reading the code.
+`Enum.sort/1` in Elixir by default sorts from lowest to highest:

-To make matters worse, comparison operators, such as `<=` and `>=`, perform structural sorting, instead of a semantic one. For example, using `>=` to sort dates descendingly won't yield the correct result. Therefore, to sort dates from more recent to oldest, one has to write `Enum.sort(dates, &(Date.compare(&1, &2) != :lt))`.
+```elixir
+iex> Enum.sort(["banana", "apple", "pineapple"])
+["apple", "banana", "pineapple"]
+```
+
+If you want to sort from highest to lowest, you need to call `Enum.sort/2` with a custom sorting function, such as `Enum.sort(collection, &>=/2)`, which is not immediately obvious to someone reading the code:
+
+```elixir
+iex> Enum.sort(["banana", "apple", "pineapple"], &>=/2)
+["pineapple", "banana", "apple"]
+```
+
+Furthermore, comparison operators, such as `<=` and `>=`, perform structural sorting, instead of a semantic one. For example, using `>=` to sort dates descendingly won't yield the correct result:
+
+```elixir
+iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]])
+[~D[2020-01-01], ~D[2019-12-31]]
+```
+
+To perform proper semantic comparison for dates, one would also need to pass a custom sorting function:
+
+```elixir
+iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], &(Date.compare(&1, &2) != :lt))
+[~D[2019-12-31], ~D[2020-01-01]]
+```

 Elixir v1.10 streamlines the sorting functions by introducing both `:asc` and `:desc` shortcuts:

-    Enum.sort(collection, :asc) # the default
-    Enum.sort(collection, :desc) # in reverse
+```elixir
+iex> Enum.sort(["banana", "apple", "pineapple"], :asc)
+["apple", "banana", "pineapple"]
+iex> Enum.sort(["banana", "apple", "pineapple"], :desc)
+["pineapple", "banana", "apple"]
+```

-Furthermore, if you want to perform semantic comparison, you can pass a module that provides the relevant comparison function. For example, to sort dates:
+As well as adding the possibility to pass a module to perform semantic comparisons. For example, to sort dates, one now only needs to pass the `Date` module or even `{:desc, Date}` for descending semantical sort:

-    Enum.sort(birth_dates, Date)
-    Enum.sort(birth_dates, {:asc, Date})
-    Enum.sort(birth_dates, {:desc, Date})
+```elixir
+iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], Date)
+[~D[2019-12-31], ~D[2020-01-01]]
+iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], {:desc, Date})
+[~D[2020-01-01], ~D[2019-12-31]]
+```

-This new API has also been added to `Enum.sort_by`, `Enum.min_by`, `Enum.max_by`, and friends.
+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

-All applications in Elixir come with an application environment. This environment is a key-value store that allows us to configure said application. While reading the application environment at runtime is the preferred approach, in some rare occasions you may want to use the application environment to configure the compilation of a certain project. This is often done by calling `Application.get_env/3` outside of a function:
+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.

-    defmodule MyApp.DBClient do
-      @db_host Application.get_env(:my_app, :db_host, "db.local")
+The application environment is a key-value store that allows us to configure said application. While reading the application environment at runtime is the preferred approach, in some rare occasions you may want to use the application environment to configure the compilation of a certain project. This is often done by calling `Application.get_env/3` outside of a function:

-      def start_link() do
-        SomeLib.DBClient.start_link(host: @db_host)
-      end
-    end
+```elixir
+defmodule MyApp.DBClient do
+  @db_host Application.get_env(:my_app, :db_host, "db.local")
+  def start_link() do
+    SomeLib.DBClient.start_link(host: @db_host)
+  end
+end
+```

 This approach has one big limitation: if you change the value of the application environment after the code is compiled, the value used at runtime is not going to change! For example, if you are using `mix release` and your `config/releases.exs` has:

    config :my_app, :db_host, "db.production"

-The new value will have no effect as the code was compiled to connect to "db.local", which is mostly likely unavailable in the production environment.
+Because `config/releases.exs` is read after the code is compiled, the new value will have no effect as the code was compiled to connect to "db.local".

-For those reasons, reading the application environment at runtime should be the first choice. However, if you really have to read the application environment during compilation, Elixir v1.10 introduces a `Application.compile_env/3` function:
+Of course, the obvious solution to this mismatch is to not read the application environment at compilation time in the first place, and instead move the code to inside a function:

-    @db_host Application.compile_env(:my_app, :db_host, "db.local")
+```elixir
+defmodule MyApp.DBClient do
+  def start_link() do
+    SomeLib.DBClient.start_link(host: db_host())
+  end
+  defp db_host() do
+    Application.get_env(:my_app, :db_host, "db.local")
+  end
+end
+```

-By using `compile_env/3`, Elixir will store the values used during compilation and compare the compilation values with the runtime values whenever your system starts, raising an error in case they differ. This helps developers ensure they are running their production systems with the configuration they intend to.
+While this is the preferred approach, there are still two scenarios we need to address:

-### Compiler tracing
+  1. Not everyone may be aware of this pitfall, so they will mistakenly read the application environemnt at compile-time, until they are bitten by this behaviour
+
+  2. In rare occasions, you trully need to read the application environment at compile-time, and you want to be warned when you try to configure at runtime something that is valid only at compilation time
+
+Elixir v1.10 aims to solve these two scenarios by introducing a `Application.compile_env/3` function. For example, to read the value at compile time, you can now do:
+
+```elixir
+@db_host Application.compile_env(:my_app, :db_host, "db.local")
+```
+
+By using `compile_env/3`, Elixir will store the values used during compilation and compare them with the runtime values whenever your system starts, raising an error in case they differ. This helps developers ensure they are running their production systems with the configuration they intend to.
+
+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

 This release brings enhancements to the Elixir compiler and adds new capabilities for developers to listen to compilation events.

-In previous Elixir releases, Elixir would compile a database of cross references between modules (such as function calls, references, structs, etc) for each project. Although developers could traverse this database, they often requested more events or more information to be made available.
+In previous Elixir versions, Elixir would compile a database of cross references between modules (such as function calls, references, structs, etc) for each project in order to perform all kinds of checks, such as deprecations and undefined functions.

-In Elixir v1.10, we have replaced this database by compiler tracing. This means that developers can now directly listen to events emitted by the compiler to store and collect all the information they need (and only the information they need).
+Although this database was not public, developers would still use it to run their own checks against their projects. With time, developers would request more data to be included in the database, which was problematic as Elixir itself did not have a use for the additional data, and the database was not meant to be used externally in the first place.

-Elixir itself is already using the new compiler tracing to provide new functionality. In particular, the compiler now checks for undefined function warnings more consistently. In previous versions, we would emit undefined function warnings only for files in `lib`, skipping test files and scripts.
+In Elixir v1.10, we have addressed these problems by introducing compiler tracing. The compiler tracing allows developers to listen to events as they are emitted by the compiler, so they can store all of the information they need - and only the information they need.

-Furthermore, in Elixir v1.10 developers can now disable undefined function warnings directly on the callsite. For example, imagine you have an optional dependency which may not be available in some cases. You can tell the compiler to skip warning on calls to optional modules with:
+Elixir itself is using the new compiler tracing to provide new functionality. One advantage of this approach is that developers can now disable undefined function warnings directly on the callsite. For example, imagine you have an optional dependency which may not be available in some cases. You can tell the compiler to skip warning on calls to optional modules with:

    @compile {:no_warn_undefined, OptionalDependency}
    defdelegate my_function_call(arg), to: OptionalDependency

-Finally, as consequence of these improvements, some functionality related to `xref` (our previous database), has been deprecated in favor of the new compiler tracing.
+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

-The 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`.
+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`.

-There are many improvements related to the Elixir AST in this release too. First of all, `Code.string_to_quoted/2` has two new options, `:token_metadata` and `:literal_encoder`, that give more control over Elixir's parser. This information has already been available to the Elixir formatter for a couple versions and has now been made public. Furthermore, all public metadata entries in the AST nodes have been extensively documented. These changes alongside the compiler improvements from previous section means tools like Credo and Boundary now have a better foundation to analyze the source code.
+There are many improvements related to Elixir's AST in this release too. First of all, `Code.string_to_quoted/2` has two new options, `:token_metadata` and `:literal_encoder`, that give more control over Elixir's parser. This information was already available to the Elixir code formatter and has now been made public. We have also extensively documented all of Elixir's AST metadata. These changes alongside compiler tracing means static analyzers and IDE integrations have a better foundation to analyze the source code.

-Finally, ExUnit comes with two small but important improvements: `ExUnit.CaptureIO` can now be used in tests that run asynchronously and we have added "data-structure diffing" when performing assertions with pattern matching. So now, whenever an assertion such `assert %{field: value} = expression()` fails, ExUnit will show both left-hand and right-hand sides, highlighting the parts that did not match in red.
+ExUnit, our test framework, ships two small but important improvements: `ExUnit.CaptureIO` can now be used by tests that run concurrently and we have added "pattern-matching diffing". To understand the last feature, take this code:

-## v1.10.0
+```elixir
+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 against a pattern.
+
+## 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)

 ### 1. Enhancements

@@ -116,6 +206,7 @@ Finally, ExUnit comes with two small but important improvements: `ExUnit.Capture
  * [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
@@ -144,7 +235,7 @@ Finally, ExUnit comes with two small but important improvements: `ExUnit.Capture
 #### Mix

  * [mix compile] Add `--profile time` flag to profile compilation steps
-  * [mix deps.compile] Add `--skip-umbrella-apps` flag. The new flag does not compile umbrella apps. This is useful for building caches in CD/CI pipelines
+  * [mix deps.compile] Add `--skip-umbrella-children` flag. The new flag does not compile umbrella apps. This is useful for building caches in CD/CI pipelines
  * [mix deps.unlock] Add `--check-unused` flag. The new flag raises if there are any unused dependencies in the lock file
  * [mix release] Allow `RELEASE_DISTRIBUTION` to be set to `none`
  * [mix release] Support overlays in `rel/overlays`
@@ -164,12 +255,15 @@ Finally, ExUnit comes with two small but important improvements: `ExUnit.Capture

  * [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
+  * [Path] Fix `Path.absname/1` to correctly handle UNC paths on Windows
  * [Stream] Close with correct accumulator in `Stream.resource/3` when called for a single-element list
  * [Stream] Allow `Stream.cycle/1` to be double nested inside `Stream.cycle/1`
  * [URI] Preserve slashes in URIs without authority
+  * [URI] Require a nil or an absolute path on URIs with host or authority

 #### IEx

@@ -192,6 +286,7 @@ Finally, ExUnit comes with two small but important improvements: `ExUnit.Capture

 #### Mix

+  * [Mix.Config] `Mix.Config.persist/1` has been deprecated. Instead of `Mix.Config.persist(config)` use `Application.put_all_env(config, persistent: true)` (`Application.put_all_env/2` was added in v1.9)
  * [mix xref] `calls/0` is deprecated in favor of compiler tracer
  * [mix xref] The `xref.exclude` option has been moved to `elixirc_options.no_warn_undefined` as the `xref` pass has been moved into the compiler

@@ -2,7 +2,7 @@ PREFIX ?= /usr/local
 TEST_FILES ?= "*_test.exs"
 SHARE_PREFIX ?= $(PREFIX)/share
 MAN_PREFIX ?= $(SHARE_PREFIX)/man
-CANONICAL := master/ # master/ or vMAJOR.MINOR/
+CANONICAL := v1.10/ # master/ or vMAJOR.MINOR/
 ELIXIRC := bin/elixirc --verbose --ignore-module-conflict $(ELIXIRC_OPTS)
 ERLC := erlc -I lib/elixir/include $(ERLC_OPTS)
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
@@ -6,12 +6,11 @@ Elixir applies bug fixes only to the latest minor branch. Security patches are a

 | Elixir version | Support
 | -------------- | ------------------------------
-| 1.10           | Development
-| 1.9            | Bug fixes and security patches
+| 1.10           | Bug fixes and security patches
+| 1.9            | Security patches only
 | 1.8            | Security patches only
 | 1.7            | Security patches only
 | 1.6            | Security patches only
-| 1.5            | Security patches only

 ## Announcements

@@ -1 +1 @@
-1.10.0-dev
+1.10.1
@@ -75,8 +75,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`.

@@ -2239,10 +2239,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
@@ -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
@@ -1530,6 +1530,11 @@ defmodule Enum do
    {:lists.reverse(list), acc}
  end

+  @doc false
+  def max(enumerable, empty_fallback) when is_function(empty_fallback, 0) do
+    max(enumerable, &>=/2, empty_fallback)
+  end
+
  @doc """
  Returns the maximal element in the `enumerable` according
  to Erlang's term ordering.
@@ -1572,26 +1577,22 @@ defmodule Enum do
      0

  """
+  @spec max(t, (() -> empty_result)) :: element | empty_result when empty_result: any
  @spec max(t, (element, element -> boolean) | module(), (() -> empty_result)) ::
          element | empty_result
        when empty_result: any
  def max(enumerable, sorter \\ &>=/2, empty_fallback \\ fn -> raise Enum.EmptyError end) do
-    {sorter, empty_fallback} = max_sort_fun(sorter, empty_fallback)
-    aggregate(enumerable, sorter, empty_fallback)
+    aggregate(enumerable, max_sort_fun(sorter), empty_fallback)
  end

-  # TODO: Deprecate me on 1.14
-  defp max_sort_fun(empty_fallback, default_empty_fallback)
-       when is_function(empty_fallback, 0) and is_function(default_empty_fallback, 0),
-       do: {&>=/2, empty_fallback}
+  defp max_sort_fun(sorter) when is_function(sorter, 2), do: sorter
+  defp max_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :lt)

-  defp max_sort_fun(sorter, empty_fallback)
-       when is_function(sorter, 2) and is_function(empty_fallback, 0),
-       do: {sorter, empty_fallback}
-
-  defp max_sort_fun(module, empty_fallback)
-       when is_atom(module) and is_function(empty_fallback, 0),
-       do: {&(module.compare(&1, &2) != :lt), empty_fallback}
+  @doc false
+  def max_by(enumerable, fun, empty_fallback)
+      when is_function(fun, 1) and is_function(empty_fallback, 0) do
+    max_by(enumerable, fun, &>=/2, empty_fallback)
+  end

  @doc """
  Returns the maximal element in the `enumerable` as calculated
@@ -1637,6 +1638,8 @@ defmodule Enum do
      nil

  """
+  @spec max_by(t, (element -> any), (() -> empty_result)) :: element | empty_result
+        when empty_result: any
  @spec max_by(
          t,
          (element -> any),
@@ -1646,8 +1649,7 @@ defmodule Enum do
        when empty_result: any
  def max_by(enumerable, fun, sorter \\ &>=/2, empty_fallback \\ fn -> raise Enum.EmptyError end)
      when is_function(fun, 1) do
-    {sorter, empty_fallback} = max_sort_fun(sorter, empty_fallback)
-    aggregate_by(enumerable, fun, sorter, empty_fallback)
+    aggregate_by(enumerable, fun, max_sort_fun(sorter), empty_fallback)
  end

  @doc """
@@ -1690,6 +1692,11 @@ defmodule Enum do
    end
  end

+  @doc false
+  def min(enumerable, empty_fallback) when is_function(empty_fallback, 0) do
+    min(enumerable, &<=/2, empty_fallback)
+  end
+
  @doc """
  Returns the minimal element in the `enumerable` according
  to Erlang's term ordering.
@@ -1728,30 +1735,26 @@ defmodule Enum do
  Finally, if you don't want to raise on empty enumerables, you can pass
  the empty fallback:

-      iex> Enum.min([], &<=/2, fn -> 0 end)
+      iex> Enum.min([], fn -> 0 end)
      0

  """
+  @spec min(t, (() -> empty_result)) :: element | empty_result when empty_result: any
  @spec min(t, (element, element -> boolean) | module(), (() -> empty_result)) ::
          element | empty_result
        when empty_result: any
  def min(enumerable, sorter \\ &<=/2, empty_fallback \\ fn -> raise Enum.EmptyError end) do
-    {sorter, empty_fallback} = min_sort_fun(sorter, empty_fallback)
-    aggregate(enumerable, sorter, empty_fallback)
+    aggregate(enumerable, min_sort_fun(sorter), empty_fallback)
  end

-  # TODO: Deprecate me on 1.14
-  defp min_sort_fun(empty_fallback, default_empty_fallback)
-       when is_function(empty_fallback, 0) and is_function(default_empty_fallback, 0),
-       do: {&<=/2, empty_fallback}
+  defp min_sort_fun(sorter) when is_function(sorter, 2), do: sorter
+  defp min_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :gt)

-  defp min_sort_fun(sorter, empty_fallback)
-       when is_function(sorter, 2) and is_function(empty_fallback, 0),
-       do: {sorter, empty_fallback}
-
-  defp min_sort_fun(module, empty_fallback)
-       when is_atom(module) and is_function(empty_fallback, 0),
-       do: {&(module.compare(&1, &2) != :gt), empty_fallback}
+  @doc false
+  def min_by(enumerable, fun, empty_fallback)
+      when is_function(fun, 1) and is_function(empty_fallback, 0) do
+    min_by(enumerable, fun, &<=/2, empty_fallback)
+  end

  @doc """
  Returns the minimal element in the `enumerable` as calculated
@@ -1799,10 +1802,16 @@ defmodule Enum do
  """
  @spec min_by(t, (element -> any), (() -> empty_result)) :: element | empty_result
        when empty_result: any
+  @spec min_by(
+          t,
+          (element -> any),
+          (element, element -> boolean) | module(),
+          (() -> empty_result)
+        ) :: element | empty_result
+        when empty_result: any
  def min_by(enumerable, fun, sorter \\ &<=/2, empty_fallback \\ fn -> raise Enum.EmptyError end)
      when is_function(fun, 1) do
-    {sorter, empty_fallback} = min_sort_fun(sorter, empty_fallback)
-    aggregate_by(enumerable, fun, sorter, empty_fallback)
+    aggregate_by(enumerable, fun, min_sort_fun(sorter), empty_fallback)
  end

  @doc """
@@ -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:

@@ -5388,7 +5384,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)
@@ -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
@@ -216,6 +216,8 @@ defmodule Module.Checker do
  # TODO: Do not warn inside guards
  # TODO: Properly handle protocols
  defp warn_undefined?(_module, :__impl__, 1, _state), do: false
+  defp warn_undefined?(_module, :module_info, 0, _state), do: false
+  defp warn_undefined?(_module, :module_info, 1, _state), do: false
  defp warn_undefined?(:erlang, :orelse, 2, _state), do: false
  defp warn_undefined?(:erlang, :andalso, 2, _state), do: false

@@ -209,7 +209,11 @@ defmodule Module.ParallelChecker do
  end

  defp cache_from_module_map(ets, map) do
-    exports = [{{:__info__, 1}, :def} | definitions_to_exports(map.definitions)]
+    exports =
+      [{{:__info__, 1}, :def}] ++
+        behaviour_exports(map) ++
+        definitions_to_exports(map.definitions)
+
    deprecated = Map.new(map.deprecated)
    cache_info(ets, map.module, exports, deprecated)
  end
@@ -227,6 +231,7 @@ defmodule Module.ParallelChecker do
  defp info_exports(module) do
    Map.new(
      [{{:__info__, 1}, :def}] ++
+        behaviour_exports(module) ++
        Enum.map(module.__info__(:macros), &{&1, :defmacro}) ++
        Enum.map(module.__info__(:functions), &{&1, :def})
    )
@@ -268,6 +273,17 @@ defmodule Module.ParallelChecker do
    :ets.insert(ets, {{:cached, module}, true})
  end

+  defp behaviour_exports(%{is_behaviour: true}), do: [{{:behaviour_info, 1}, :def}]
+  defp behaviour_exports(%{is_behaviour: false}), do: []
+
+  defp behaviour_exports(module) when is_atom(module) do
+    if {:behaviour_info, 1} in module.module_info(:functions) do
+      [{{:behaviour_info, 1}, :def}]
+    else
+      []
+    end
+  end
+
  defp definitions_to_exports(definitions) do
    Enum.flat_map(definitions, fn {function, kind, _meta, _clauses} ->
      if kind in [:def, :defmacro] do
@@ -57,7 +57,7 @@ defmodule Module.Types do
  def of_head(params, guards, stack, context) do
    with {:ok, types, context} <-
           map_reduce_ok(params, context, &Pattern.of_pattern(&1, stack, &2)),
-         # TODO: Check that of_guard/3 returns a boolean
+         # TODO: Check that of_guard/3 returns boolean() | :fail
         {:ok, _, context} <- Pattern.of_guard(guards_to_or(guards), stack, context),
         do: {:ok, lift_types(types, context), context}
  end
@@ -258,7 +258,7 @@ defmodule Module.Types do

  def format_warning({:unable_unify, left, right, expr, traces}) do
    [
-      "function clause will never match, found incompatibility:\n\n    ",
+      "incompatible types:\n\n    ",
      format_type(left),
      " !~ ",
      format_type(right),
@@ -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},
@@ -333,10 +334,9 @@ defmodule Module.Types.Pattern do
    fresh_context = fresh_context(context)

    with {:ok, left_type, left_context} <- of_guard(left, stack, fresh_context),
-         {:ok, right_type, right_context} <- of_guard(right, stack, fresh_context),
+         {:ok, _right_type, right_context} <- of_guard(right, stack, fresh_context),
         {:ok, context} <- merge_context_or(context, stack, left_context, right_context),
         {:ok, _, context} <- unify(left_type, :boolean, stack, context),
-         {:ok, _, context} <- unify(right_type, :boolean, stack, context),
         do: {:ok, :boolean, context}
  end

@@ -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

@@ -8,12 +8,11 @@ Elixir applies bug fixes only to the latest minor branch. Security patches are a

 Elixir version | Support
 :------------- | :-----------------------------
-1.10           | Development
-1.9            | Bug fixes and security patches
+1.10           | Bug fixes and security patches
+1.9            | Security patches only
 1.8            | Security patches only
 1.7            | Security patches only
 1.6            | Security patches only
-1.5            | Security patches only

 New releases are announced in the read-only [announcements mailing list](https://groups.google.com/group/elixir-lang-ann). All security releases [will be tagged with `[security]`](https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date).

@@ -171,4 +170,4 @@ Version | Deprecated feature                                  | Replaced by (ava
 [v1.7]: https://github.com/elixir-lang/elixir/blob/v1.7/CHANGELOG.md#4-hard-deprecations
 [v1.8]: https://github.com/elixir-lang/elixir/blob/v1.8/CHANGELOG.md#4-hard-deprecations
 [v1.9]: https://github.com/elixir-lang/elixir/blob/v1.9/CHANGELOG.md#4-hard-deprecations
-[v1.10]: https://github.com/elixir-lang/elixir/blob/master/CHANGELOG.md#4-hard-deprecations
+[v1.10]: https://github.com/elixir-lang/elixir/blob/v1.10/CHANGELOG.md#4-hard-deprecations
@@ -144,6 +144,34 @@ The application environment should be reserved only for configurations that are

 For all remaining scenarios, libraries should not force their users to use the application environment for configuration. If the user of a library believes that certain parameter should be configured globally, then they can wrap the library functionality with their own application environment configuration.

+### Avoid compile-time application configuration
+
+Assuming you need to use the application configuration and you cannot avoid it as explained in the previous section, you should also avoid compile-time application configuration. For example, instead of doing this:
+
+```elixir
+@http_client Application.fetch_env!(:my_app, :http_client)
+
+def request(path) do
+  @http_client.request(path)
+end
+```
+
+you should do this:
+
+```elixir
+def request(path) do
+  http_client().request(path)
+end
+
+defp http_client() do
+  Application.fetch_env!(:my_app, :http_client)
+end
+```
+
+That's because by reading the application in the module body and storing it in a module attribute, we are effectively reading the configuration at compile-time, which may become an issue when configuring the system later.
+
+If, for some reason, you must read the application environment at compile time, use `Application.compile_env/2`. Read [the "Compile-time environment" section of the Application docs](Application.html#module-compile-time-environment) for more information.
+
 ### Avoid `use` when an `import` is enough

 A library should not provide `use MyLib` functionality if all `use MyLib` does is to `import`/`alias` the module itself. For example, this is an anti-pattern:
@@ -16,17 +16,6 @@
  stacktrace=nil           %% holds information about the stacktrace variable
 }).

-record(elixir_quote, {
-  line=false,
-  file=nil,
-  context=nil,
-  vars_hygiene=true,
-  aliases_hygiene=true,
-  imports_hygiene=true,
-  unquote=true,
-  generated=false
-}).
-
 -record(elixir_tokenizer, {
  file=(<<"nofile">>),
  terminators=[],
@@ -132,17 +132,16 @@ compute_alignment(_, _, _) -> unknown.

 %% Expands the expression of a bitstring, that is, the LHS of :: or
 %% an argument of the bitstring (such as "foo" in "<<foo>>").
+%% If we are inside a match/guard, we inline interpolations explicitly,
+%% otherwise they are inlined by elixir_rewrite.erl.

-expand_expr(Meta, {{'.', M1, [Mod, to_string]}, M2, [Arg]}, Fun, E)
-    when Mod == 'Elixir.Kernel'; Mod == 'Elixir.String.Chars' ->
+expand_expr(_Meta, {{'.', _, [Mod, to_string]}, _, [Arg]} = AST, Fun, {#{context := Context}, _} = E)
+    when Context /= nil, (Mod == 'Elixir.Kernel') orelse (Mod == 'Elixir.String.Chars') ->
  case Fun(Arg, E) of
    {EBin, EE} when is_binary(EBin) -> {EBin, EE};
-    _ -> do_expand_expr(Meta, {{'.', M1, ['Elixir.String.Chars', to_string]}, M2, [Arg]}, Fun, E)
+    _ -> Fun(AST, E) % Let it raise
  end;
 expand_expr(Meta, Component, Fun, E) ->
-  do_expand_expr(Meta, Component, Fun, E).
-
-do_expand_expr(Meta, Component, Fun, E) ->
  case Fun(Component, E) of
    {EComponent, {ErrorE, _}} when is_list(EComponent); is_atom(EComponent) ->
      form_error(Meta, ErrorE, ?MODULE, {invalid_literal, EComponent});
@@ -549,7 +549,7 @@ signature_to_binary(Module, '__struct__', []) ->
 signature_to_binary(_, Name, Signature) ->
  'Elixir.Macro':to_string({Name, [], Signature}).

-checker_chunk(#{definitions := Definitions, deprecated := Deprecated}, NoWarnUndefined) ->
+checker_chunk(#{definitions := Definitions, deprecated := Deprecated, is_behaviour := IsBehaviour}, NoWarnUndefined) ->
  DeprecatedMap = maps:from_list(Deprecated),

  Exports =
@@ -564,12 +564,15 @@ checker_chunk(#{definitions := Definitions, deprecated := Deprecated}, NoWarnUnd
    end, [], Definitions),

  Contents = #{
-    exports => lists:sort(Exports),
+    exports => lists:sort(behaviour_info_exports(IsBehaviour) ++ Exports),
    no_warn_undefined => NoWarnUndefined
  },

  [{<<"ExCk">>, erlang:term_to_binary({elixir_checker_v1, Contents})}].

+behaviour_info_exports(true) -> [{{behaviour_info, 1}, #{kind => def, deprecated_reason => nil}}];
+behaviour_info_exports(false) -> [].
+
 split_no_warn_undefined([{no_warn_undefined, NoWarnUndefined} | CompileOpts], AccNWU, AccCO) ->
  split_no_warn_undefined(CompileOpts, list_wrap(NoWarnUndefined) ++ AccNWU, AccCO);
 split_no_warn_undefined([Opt | CompileOpts], AccNWU, AccCO) ->
@@ -126,7 +126,7 @@ translate({'cond', CondMeta, [[{do, Clauses}]]}, S) ->
      true -> Meta
    end,

-  Error = {{'.', Meta, [erlang, error]}, [], [cond_clause]},
+  Error = {{'.', Meta, [erlang, error]}, Meta, [cond_clause]},
  {Case, SC} = build_cond_clauses([H | T], Error, FirstMeta, S),
  translate(replace_case_meta(CondMeta, Case), SC);

@@ -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};
@@ -528,29 +528,20 @@ extract_bit_type({Other, _, []}, Acc) ->
 %% Optimizations that are specific to Erlang and change
 %% the format of the AST.

-translate_remote('Elixir.Access' = Mod, get, Meta, [Container, Value], S) ->
-  Ann = ?ann(Meta),
-  {TArgs, SA} = translate_args([Container, Value, nil], S),
-  {?remote(Ann, Mod, get, TArgs), SA};
 translate_remote('Elixir.String.Chars', to_string, Meta, [Arg], S) ->
-  case is_always_string(Arg) of
-    true ->
-      translate(Arg, S);
-    false ->
-      {TArg, TS} = translate(Arg, S),
-      {VarName, VS} = elixir_erl_var:build('_', TS),
+  {TArg, TS} = translate(Arg, S),
+  {VarName, VS} = elixir_erl_var:build('_', TS),

-      Generated = ?ann(?generated(Meta)),
-      Var = {var, Generated, VarName},
-      Guard = ?remote(Generated, erlang, is_binary, [Var]),
-      Slow = ?remote(Generated, 'Elixir.String.Chars', to_string, [Var]),
-      Fast = Var,
+  Generated = ?ann(?generated(Meta)),
+  Var = {var, Generated, VarName},
+  Guard = ?remote(Generated, erlang, is_binary, [Var]),
+  Slow = ?remote(Generated, 'Elixir.String.Chars', to_string, [Var]),
+  Fast = Var,

-      {{'case', Generated, TArg, [
-        {clause, Generated, [Var], [[Guard]], [Fast]},
-        {clause, Generated, [Var], [], [Slow]}
-      ]}, VS}
-  end;
+  {{'case', Generated, TArg, [
+    {clause, Generated, [Var], [[Guard]], [Fast]},
+    {clause, Generated, [Var], [], [Slow]}
+  ]}, VS};
 translate_remote(maps, put, Meta, [Key, Value, Map], S) ->
  Ann = ?ann(Meta),

@@ -600,20 +591,6 @@ translate_remote(Left, Right, Meta, Args, S) ->
      {{call, Ann, {remote, Ann, TLeft, TRight}, TArgs}, SA}
  end.

-is_always_string({{'.', _, [Module, Function]}, _, Args}) ->
-  is_always_string(Module, Function, length(Args));
-%% Binary literals were already excluded in earlier passes.
-is_always_string(_Ast) ->
-  false.
-
-is_always_string('Elixir.Enum', join, _) -> true;
-is_always_string('Elixir.Enum', map_join, _) -> true;
-is_always_string('Elixir.Kernel', inspect, _) -> true;
-is_always_string('Elixir.Macro', to_string, _) -> true;
-is_always_string('Elixir.String.Chars', to_string, _) -> true;
-is_always_string('Elixir.Path', join, _) -> true;
-is_always_string(_Module, _Function, _Args) -> false.
-
 generate_struct_name_guard([{map_field_exact, Ann, {atom, _, '__struct__'} = Key, Var} | Rest], Acc, S0) ->
  {ModuleVarName, S1} = elixir_erl_var:build('_', S0),
  Generated = erl_anno:set_generated(true, Ann),
@@ -156,31 +156,16 @@ expand({quote, Meta, [Opts, Do]}, E) when is_list(Do) ->
  ValidOpts = [context, location, line, file, unquote, bind_quoted, generated],
  {EOpts, ET} = expand_opts(Meta, quote, ValidOpts, Opts, E),

-  Context = case lists:keyfind(context, 1, EOpts) of
-    {context, Ctx} when is_atom(Ctx) and (Ctx /= nil) ->
-      Ctx;
-    {context, Ctx} ->
-      form_error(Meta, E, ?MODULE, {invalid_context_for_quote, Ctx});
-    false ->
-      case ?key(E, module) of
-        nil -> 'Elixir';
-        Mod -> Mod
-      end
-  end,
+  Context = proplists:get_value(context, EOpts, case ?key(E, module) of
+    nil -> 'Elixir';
+    Mod -> Mod
+  end),

  {File, Line} = case lists:keyfind(location, 1, EOpts) of
    {location, keep} ->
      {elixir_utils:relative_to_cwd(?key(E, file)), false};
    false ->
-      { case lists:keyfind(file, 1, EOpts) of
-          {file, F} -> F;
-          false -> nil
-        end,
-
-        case lists:keyfind(line, 1, EOpts) of
-          {line, L} -> L;
-          false -> false
-        end }
+      {proplists:get_value(file, EOpts, nil), proplists:get_value(line, EOpts, false)}
  end,

  {Binding, DefaultUnquote} = case lists:keyfind(bind_quoted, 1, EOpts) of
@@ -191,20 +176,14 @@ expand({quote, Meta, [Opts, Do]}, E) when is_list(Do) ->
        false -> form_error(Meta, E, ?MODULE, {invalid_bind_quoted_for_quote, BQ})
      end;
    false ->
-      {nil, true}
+      {[], true}
  end,

-  Unquote = case lists:keyfind(unquote, 1, EOpts) of
-    {unquote, U} when is_boolean(U) -> U;
-    false -> DefaultUnquote
-  end,
+  Unquote = proplists:get_value(unquote, EOpts, DefaultUnquote),
+  Generated = proplists:get_value(generated, EOpts, false),

-  Generated = lists:keyfind(generated, 1, EOpts) == {generated, true},
-
-  Q = #elixir_quote{line=Line, file=File, unquote=Unquote,
-                    context=Context, generated=Generated},
-
-  Quoted = elixir_quote:quote(Meta, Exprs, Binding, Q, ET),
+  {Q, Prelude} = elixir_quote:build(Meta, Line, File, Context, Unquote, Generated),
+  Quoted = elixir_quote:quote(Meta, Exprs, Binding, Q, Prelude, ET),
  expand(Quoted, ET);

 expand({quote, Meta, [_, _]}, E) ->
@@ -1133,9 +1112,6 @@ format_error({expected_compile_time_module, Kind, GivenTerm}) ->
 format_error({unquote_outside_quote, Unquote}) ->
  %% Unquote can be "unquote" or "unquote_splicing".
  io_lib:format("~p called outside quote", [Unquote]);
-format_error({invalid_context_for_quote, Context}) ->
-  io_lib:format("invalid :context for quote, expected non-nil compile time atom or alias, got: ~ts",
-                ['Elixir.Macro':to_string(Context)]);
 format_error({invalid_bind_quoted_for_quote, BQ}) ->
  io_lib:format("invalid :bind_quoted for quote, expected a keyword list of variable names, got: ~ts",
                ['Elixir.Macro':to_string(BQ)]);
@@ -87,7 +87,13 @@ validate_match_key(_, _, _) ->
 validate_not_repeated(Meta, Key, Used, E) ->
  case is_literal(Key) andalso Used of
    #{Key := true} ->
-      form_error(Meta, ?key(E, file), ?MODULE, {repeated_key, Key});
+      case E of
+        #{context := match} ->
+          form_error(Meta, ?key(E, file), ?MODULE, {repeated_key, Key});
+        _ ->
+          form_warn(Meta, ?key(E, file), ?MODULE, {repeated_key, Key}),
+          Used
+      end;

    #{} ->
      Used#{Key => true};
@@ -133,7 +133,8 @@ compile(Line, Module, Block, Vars, E) ->
      definitions => AllDefinitions,
      unreachable => Unreachable,
      compile_opts => CompileOpts,
-      deprecated => get_deprecated(DataBag)
+      deprecated => get_deprecated(DataBag),
+      is_behaviour => is_behaviour(DataBag)
    },

    Binary = elixir_erl:compile(ModuleMap),
@@ -199,6 +200,9 @@ validate_on_load_attribute({on_load, Def}, Defs, File, Line) ->
  end;
 validate_on_load_attribute(false, _Defs, _File, _Line) -> ok.

+is_behaviour(DataBag) ->
+  ets:member(DataBag, {accumulate, callback}) orelse ets:member(DataBag, {accumulate, macrocallback}).
+
 %% An undef error for a function in the module being compiled might result in an
 %% exception message suggesting the current module is not loaded. This is
 %% misleading so use a custom reason.
@@ -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'].
@@ -1,12 +1,73 @@
 -module(elixir_quote).
-export([escape/3, linify/3, linify_with_context_counter/3, quote/5, has_unquotes/1]).
-export([dot/5, tail_list/3, list/2]). %% Quote callbacks
+-export([escape/3, linify/3, linify_with_context_counter/3, build/6, quote/6, has_unquotes/1]).
+-export([dot/5, tail_list/3, list/2, validate_runtime/2]). %% Quote callbacks

 -include("elixir.hrl").
 -define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop; Kind == '@').
 -define(lexical(Kind), Kind == import; Kind == alias; Kind == require).
 -compile({inline, [keyfind/2, keystore/3, keydelete/2, keynew/3, do_tuple_linify/5]}).

+-record(elixir_quote, {
+  line=false,
+  file=nil,
+  context=nil,
+  vars_hygiene=true,
+  aliases_hygiene=true,
+  imports_hygiene=true,
+  unquote=true,
+  generated=false
+}).
+
+build(Meta, Line, File, Context, Unquote, Generated) ->
+  Acc0 = [],
+  {ELine, Acc1} = validate_compile(Meta, line, Line, Acc0),
+  {EFile, Acc2} = validate_compile(Meta, file, File, Acc1),
+  {EContext, Acc3} = validate_compile(Meta, context, Context, Acc2),
+  validate_runtime(unquote, Unquote),
+  validate_runtime(generated, Generated),
+
+  Q = #elixir_quote{
+    line=ELine,
+    file=EFile,
+    unquote=Unquote,
+    context=EContext,
+    generated=Generated
+  },
+
+  {Q, Acc3}.
+
+validate_compile(_Meta, file, nil, Acc) ->
+  {nil, Acc};
+validate_compile(Meta, Key, Value, Acc) ->
+  case is_valid(Key, Value) of
+    true ->
+      {Value, Acc};
+    false ->
+      Var = {Key, Meta, ?MODULE},
+      Call = {{'.', Meta, [?MODULE, validate_runtime]}, Meta, [Key, Value]},
+      {Var, [{'=', Meta, [Var, Call]} | Acc]}
+  end.
+
+validate_runtime(Key, Value) ->
+  case is_valid(Key, Value) of
+    true ->
+      Value;
+
+    false ->
+      erlang:error(
+        'Elixir.ArgumentError':exception(
+          <<"invalid value for option :", (erlang:atom_to_binary(Key, utf8))/binary,
+            " in quote, got: ", ('Elixir.Kernel':inspect(Value))/binary>>
+        )
+      )
+  end.
+
+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).
+
 %% Apply the line from site call on quoted contents.
 %% Receives a Key to look for the default line as argument.
 linify(0, _Key, Exprs) ->
@@ -164,26 +225,31 @@ escape(Expr, Kind, Unquote) ->

 %% Quotes an expression and return its quoted Elixir AST.

-quote(_Meta, {unquote_splicing, _, [_]}, _Binding, #elixir_quote{unquote=true}, _) ->
+quote(_Meta, {unquote_splicing, _, [_]}, _Binding, #elixir_quote{unquote=true}, _, _) ->
  argument_error(<<"unquote_splicing only works inside arguments and block contexts, "
    "wrap it in parens if you want it to work with one-liners">>);

-quote(_Meta, Expr, nil, Q, E) ->
-  do_quote(Expr, Q, E);
-
-quote(Meta, Expr, Binding, Q, E) ->
+quote(Meta, Expr, Binding, Q, Prelude, E) ->
  Context = Q#elixir_quote.context,
-  VarMeta = [Pair || {K, _} = Pair <- Meta, K == counter],

-  Vars = [ {'{}', [],
-    [ '=', [], [
-      {'{}', [], [K, VarMeta, Context]},
+  Vars = [{'{}', [],
+    ['=', [], [
+      {'{}', [], [K, Meta, Context]},
      V
-    ] ]
+    ]]
  } || {K, V} <- Binding],

-  TExprs = do_quote(Expr, Q, E),
-  {'{}', [], ['__block__', [], Vars ++ [TExprs]]}.
+  Quoted = do_quote(Expr, Q, E),
+
+  WithVars = case Vars of
+    [] -> Quoted;
+    _ -> {'{}', [], ['__block__', [], Vars ++ [Quoted]]}
+  end,
+
+  case Prelude of
+    [] -> WithVars;
+    _ -> {'__block__', [], Prelude ++ [WithVars]}
+  end.

 %% Actual quoting and helpers

@@ -224,11 +290,12 @@ do_quote({'__aliases__', Meta, [H | T]} = Alias, #elixir_quote{aliases_hygiene=t

 %% Vars

-do_quote({Left, Meta, nil}, #elixir_quote{vars_hygiene=true, imports_hygiene=true} = Q, E) when is_atom(Left) ->
-  do_quote_import(Left, Meta, Q#elixir_quote.context, Q, E);
+do_quote({Name, Meta, nil}, #elixir_quote{vars_hygiene=true, imports_hygiene=true} = Q, E) when is_atom(Name) ->
+  ImportMeta = import_meta(Meta, Name, 0, Q, E),
+  {'{}', [], [Name, meta(ImportMeta, Q), Q#elixir_quote.context]};

-do_quote({Left, Meta, nil}, #elixir_quote{vars_hygiene=true} = Q, E) when is_atom(Left) ->
-  do_quote_tuple(Left, Meta, Q#elixir_quote.context, Q, E);
+do_quote({Name, Meta, nil}, #elixir_quote{vars_hygiene=true} = Q, _E) when is_atom(Name) ->
+  {'{}', [], [Name, meta(Meta, Q), Q#elixir_quote.context]};

 %% Unquote

@@ -244,8 +311,11 @@ do_quote({'&', Meta, [{'/', _, [{F, _, C}, A]}] = Args},
         #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(F), is_integer(A), is_atom(C) ->
  do_quote_fa('&', Meta, Args, F, A, Q, E);

-do_quote({Name, Meta, ArgsOrAtom}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name) ->
-  do_quote_import(Name, Meta, ArgsOrAtom, Q, E);
+do_quote({Name, Meta, Args}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name), is_list(Args) ->
+  do_quote_import(Meta, Name, length(Args), Args, Q, E);
+
+do_quote({Name, Meta, Context}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name), is_atom(Context) ->
+  do_quote_import(Meta, Name, 0, Context, Q, E);

 %% Two-element tuples

@@ -341,15 +411,8 @@ bad_escape(Arg) ->
                   "The supported values are: lists, tuples, maps, atoms, numbers, bitstrings, ",
                   "PIDs and remote functions in the format &Mod.fun/arity">>).

-%% do_quote_*
-
-do_quote_import(Name, Meta, ArgsOrAtom, #elixir_quote{imports_hygiene=true} = Q, E) ->
-  Arity = case is_atom(ArgsOrAtom) of
-    true  -> 0;
-    false -> length(ArgsOrAtom)
-  end,
-
-  NewMeta = case (keyfind(import, Meta) == false) andalso
+import_meta(Meta, Name, Arity, Q, E) ->
+  case (keyfind(import, Meta) == false) andalso
      elixir_dispatch:find_import(Meta, Name, Arity, E) of
    false ->
      case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of
@@ -358,9 +421,13 @@ do_quote_import(Name, Meta, ArgsOrAtom, #elixir_quote{imports_hygiene=true} = Q,
      end;
    Receiver ->
      keystore(import, keystore(context, Meta, Q#elixir_quote.context), Receiver)
-  end,
+  end.

-  Annotated = annotate({Name, NewMeta, ArgsOrAtom}, Q#elixir_quote.context),
+%% do_quote_*
+
+do_quote_import(Meta, Name, Arity, ArgsOrAtom, Q, E) ->
+  ImportMeta = import_meta(Meta, Name, Arity, Q, E),
+  Annotated = annotate({Name, ImportMeta, ArgsOrAtom}, Q#elixir_quote.context),
  do_quote_tuple(Annotated, Q, E).

 do_quote_call(Left, Meta, Expr, Args, Q, E) ->
@@ -1,5 +1,5 @@
 -module(elixir_rewrite).
-compile({inline, [inner_inline/4, inner_rewrite/4]}).
+-compile({inline, [inner_inline/4, inner_rewrite/5]}).
 -export([erl_to_ex/3, inline/3, rewrite/5, match_rewrite/5, guard_rewrite/5, format_error/1]).
 -include("elixir.hrl").

@@ -34,13 +34,13 @@

 -define(
  rewrite(ExMod, ExFun, ExArgs, ErlMod, ErlFun, ErlArgs),
-  inner_rewrite(ex_to_erl, ExMod, ExFun, ExArgs) -> {ErlMod, ErlFun, ErlArgs};
-  inner_rewrite(erl_to_ex, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs}
+  inner_rewrite(ex_to_erl, _Meta, ExMod, ExFun, ExArgs) -> {ErlMod, ErlFun, ErlArgs};
+  inner_rewrite(erl_to_ex, _Meta, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs}
 ).

 erl_to_ex(Mod, Fun, Args) ->
  case inner_inline(erl_to_ex, Mod, Fun, length(Args)) of
-    false -> inner_rewrite(erl_to_ex, Mod, Fun, Args);
+    false -> inner_rewrite(erl_to_ex, [], Mod, Fun, Args);
    {ExMod, ExFun} -> {ExMod, ExFun, Args}
  end.

@@ -223,12 +223,13 @@ inner_inline(_, _, _, _) -> false.
 %% as they may change the number of arguments. However, they
 %% don't add new code (such as case statements), at best they
 %% perform dead code removal.
-rewrite(?string_chars, _, to_string, _, [String]) when is_binary(String) ->
-  String;
-rewrite(?string_chars, _, to_string, _, [{{'.', _, [?kernel, inspect]}, _, _} = Call]) ->
-  Call;
+rewrite(?string_chars, DotMeta, to_string, Meta, [Arg]) ->
+  case is_always_string(Arg) of
+    true -> Arg;
+    false -> {{'.', DotMeta, [?string_chars, to_string]}, Meta, [Arg]}
+  end;
 rewrite(Receiver, DotMeta, Right, Meta, Args) ->
-  {EReceiver, ERight, EArgs} = inner_rewrite(ex_to_erl, Receiver, Right, Args),
+  {EReceiver, ERight, EArgs} = inner_rewrite(ex_to_erl, DotMeta, Receiver, Right, Args),
  {{'.', DotMeta, [EReceiver, ERight]}, Meta, EArgs}.

 ?rewrite(?atom, to_string, [Arg], erlang, atom_to_binary, [Arg, utf8]);
@@ -248,39 +249,39 @@ rewrite(Receiver, DotMeta, Right, Meta, Args) ->
 ?rewrite(?string, to_existing_atom, [Arg], erlang, binary_to_existing_atom, [Arg, utf8]);
 ?rewrite(?tuple, duplicate, [Data, Size], erlang, make_tuple, [Size, Data]);

-inner_rewrite(ex_to_erl, ?tuple, delete_at, [Tuple, Index]) ->
-  {erlang, delete_element, [increment(Index), Tuple]};
-inner_rewrite(ex_to_erl, ?tuple, insert_at, [Tuple, Index, Term]) ->
-  {erlang, insert_element, [increment(Index), Tuple, Term]};
-inner_rewrite(ex_to_erl, ?kernel, elem, [Tuple, Index]) ->
-  {erlang, element, [increment(Index), Tuple]};
-inner_rewrite(ex_to_erl, ?kernel, put_elem, [Tuple, Index, Value]) ->
-  {erlang, setelement, [increment(Index), Tuple, Value]};
+inner_rewrite(ex_to_erl, Meta, ?tuple, delete_at, [Tuple, Index]) ->
+  {erlang, delete_element, [increment(Meta, Index), Tuple]};
+inner_rewrite(ex_to_erl, Meta, ?tuple, insert_at, [Tuple, Index, Term]) ->
+  {erlang, insert_element, [increment(Meta, Index), Tuple, Term]};
+inner_rewrite(ex_to_erl, Meta, ?kernel, elem, [Tuple, Index]) ->
+  {erlang, element, [increment(Meta, Index), Tuple]};
+inner_rewrite(ex_to_erl, Meta, ?kernel, put_elem, [Tuple, Index, Value]) ->
+  {erlang, setelement, [increment(Meta, Index), Tuple, Value]};

-inner_rewrite(erl_to_ex, erlang, delete_element, [Index, Tuple]) when is_number(Index) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [Index, Tuple]) when is_number(Index) ->
  {?tuple, delete_at, [Tuple, Index - 1]};
-inner_rewrite(erl_to_ex, erlang, insert_element, [Index, Tuple, Term]) when is_number(Index) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [Index, Tuple, Term]) when is_number(Index) ->
  {?tuple, insert_at, [Tuple, Index - 1, Term]};
-inner_rewrite(erl_to_ex, erlang, element, [Index, Tuple]) when is_number(Index) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, element, [Index, Tuple]) when is_number(Index) ->
  {?kernel, elem, [Tuple, Index - 1]};
-inner_rewrite(erl_to_ex, erlang, setelement, [Index, Tuple, Value]) when is_number(Index) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [Index, Tuple, Value]) when is_number(Index) ->
  {?kernel, put_elem, [Tuple, Index - 1, Value]};

-inner_rewrite(erl_to_ex, erlang, delete_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
  {?tuple, delete_at, [Tuple, Index]};
-inner_rewrite(erl_to_ex, erlang, insert_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->
  {?tuple, insert_at, [Tuple, Index, Term]};
-inner_rewrite(erl_to_ex, erlang, element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
  {?kernel, elem, [Tuple, Index]};
-inner_rewrite(erl_to_ex, erlang, setelement, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Value]) ->
+inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Value]) ->
  {?kernel, put_elem, [Tuple, Index, Value]};

-inner_rewrite(_To, Mod, Fun, Args) -> {Mod, Fun, Args}.
+inner_rewrite(_To, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args}.

-increment(Number) when is_number(Number) ->
+increment(_Meta, Number) when is_number(Number) ->
  Number + 1;
-increment(Other) ->
-  {{'.', [], [erlang, '+']}, [], [Other, 1]}.
+increment(Meta, Other) ->
+  {{'.', Meta, [erlang, '+']}, Meta, [Other, 1]}.

 %% Match rewrite
 %%
@@ -312,7 +313,7 @@ static_append(_, _, _) -> throw(impossible).
 %% it also verifies the resulting function is supported in
 %% guard context - only certain BIFs and operators are.
 guard_rewrite(Receiver, DotMeta, Right, Meta, Args) ->
-  case inner_rewrite(ex_to_erl, Receiver, Right, Args) of
+  case inner_rewrite(ex_to_erl, DotMeta, Receiver, Right, Args) of
    {erlang, RRight, RArgs} ->
      case allowed_guard(RRight, length(RArgs)) of
        true -> {ok, {{'.', DotMeta, [erlang, RRight]}, Meta, RArgs}};
@@ -333,3 +334,16 @@ format_error({invalid_match, Receiver, Right, Arity}) ->
 format_error({invalid_match_append, Arg}) ->
  io_lib:format("invalid argument for ++ operator inside a match, expected a literal proper list, got: ~ts",
                ['Elixir.Macro':to_string(Arg)]).
+
+is_always_string({{'.', _, [Module, Function]}, _, Args}) ->
+  is_always_string(Module, Function, length(Args));
+is_always_string(Ast) ->
+  is_binary(Ast).
+
+is_always_string('Elixir.Enum', join, _) -> true;
+is_always_string('Elixir.Enum', map_join, _) -> true;
+is_always_string('Elixir.Kernel', inspect, _) -> true;
+is_always_string('Elixir.Macro', to_string, _) -> true;
+is_always_string('Elixir.String.Chars', to_string, _) -> true;
+is_always_string('Elixir.Path', join, _) -> true;
+is_always_string(_Module, _Function, _Args) -> false.
@@ -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 """
      %{
@@ -111,7 +111,7 @@ defmodule CodeTest do
        Code.compile_file(PathHelpers.fixture_path("checker_warning.exs"))
      end)

-    assert output =~ "function clause will never match"
+    assert output =~ "incompatible types"
  end

  test "require_file/1" do
@@ -338,20 +338,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 +361,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
@@ -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,7 +80,7 @@ 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: {:"£", "£", '£'}]]
@@ -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()

@@ -8,11 +8,9 @@ defmodule IntegerTest do
  require Integer

  def test_is_odd_in_guards(number) when Integer.is_odd(number), do: number
-  def test_is_odd_in_guards(atom) when is_atom(atom) and not Integer.is_odd(atom), do: :atom
  def test_is_odd_in_guards(_number), do: false

  def test_is_even_in_guards(number) when Integer.is_even(number), do: number
-  def test_is_even_in_guards(atom) when is_atom(atom) and not Integer.is_even(atom), do: :atom
  def test_is_even_in_guards(_number), do: false

  test "is_odd/1" do
@@ -25,7 +23,7 @@ defmodule IntegerTest do
    assert Integer.is_odd(-3) == true
    assert test_is_odd_in_guards(10) == false
    assert test_is_odd_in_guards(11) == 11
-    assert test_is_odd_in_guards(:not_integer) == :atom
+    assert test_is_odd_in_guards(:not_integer) == false
  end

  test "is_even/1" do
@@ -38,7 +36,7 @@ defmodule IntegerTest do
    assert Integer.is_even(-3) == false
    assert test_is_even_in_guards(10) == 10
    assert test_is_even_in_guards(11) == false
-    assert test_is_even_in_guards(:not_integer) == :atom
+    assert test_is_even_in_guards(:not_integer) == false
  end

  test "mod/2" do
@@ -1226,23 +1226,13 @@ defmodule Kernel.ErrorsTest do
  end

  test "duplicate map keys" do
-    assert_eval_raise CompileError, "nofile:1: key :a will be overridden in map", """
-      %{a: :b, a: :c}
-    """
-
    assert_eval_raise CompileError, "nofile:1: key :a will be overridden in map", """
      %{a: :b, a: :c} = %{a: :c}
    """

-    assert_eval_raise CompileError, "nofile:1: key :m will be overridden in map", """
-      %{m: :n, m: :o, m: :p}
+    assert_eval_raise CompileError, "nofile:1: key :a will be overridden in map", """
+      %{a: :b, a: :c, a: :d} = %{a: :c}
    """
-
-    assert_eval_raise CompileError, "nofile:1: key 1 will be overridden in map", """
-      %{1 => 2, 1 => 3}
-    """
-
-    assert map_size(%{System.unique_integer() => 1, System.unique_integer() => 2}) == 2
  end

  defp bad_remote_call(x), do: x.foo
@@ -3,6 +3,11 @@ Code.require_file("../test_helper.exs", __DIR__)
 defmodule Kernel.ExpansionTarget do
  defmacro seventeen, do: 17
  defmacro bar, do: "bar"
+
+  defmacro message_hello(arg) do
+    send(self(), :hello)
+    arg
+  end
 end

 defmodule Kernel.ExpansionTest do
@@ -543,16 +548,6 @@ defmodule Kernel.ExpansionTest do
      assert expand(quote(do: quote(do: hello))) == {:{}, [], [:hello, [], __MODULE__]}
    end

-    test "raises if the :context option is invalid" do
-      assert_raise CompileError, ~r"invalid :context for quote, .*, got: :erlang\.self\(\)", fn ->
-        expand(quote(do: quote(context: self(), do: :ok)))
-      end
-
-      assert_raise CompileError, ~r"invalid :context for quote, .*, got: nil", fn ->
-        expand(quote(do: quote(context: nil, do: :ok)))
-      end
-    end
-
    test "raises if the :bind_quoted option is invalid" do
      assert_raise CompileError, ~r"invalid :bind_quoted for quote", fn ->
        expand(quote(do: quote(bind_quoted: self(), do: :ok)))
@@ -2149,6 +2144,14 @@ defmodule Kernel.ExpansionTest do
    test "inlines binaries inside interpolation" do
      import Kernel.ExpansionTarget

+      # Check expansion happens only once
+      assert expand(quote(do: "foo#{message_hello("bar")}")) |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary(), "bar"::binary()>>)
+
+      assert_received :hello
+      refute_received :hello
+
+      # And it also works in match
      assert expand(quote(do: "foo#{bar()}" = "foobar")) |> clean_meta([:alignment]) ==
               quote(do: <<"foo"::binary(), "bar"::binary()>> = "foobar")
    end
@@ -12,9 +12,10 @@ defmodule Kernel.QuoteTest do
  end

  test "keep line" do
-    # DO NOT MOVE THIS LINE
+    line = __ENV__.line + 2
+
    assert quote(location: :keep, do: bar(1, 2, 3)) ==
-             {:bar, [keep: {Path.relative_to_cwd(__ENV__.file), 16}], [1, 2, 3]}
+             {:bar, [keep: {Path.relative_to_cwd(__ENV__.file), line}], [1, 2, 3]}
  end

  test "fixed line" do
@@ -22,9 +23,23 @@ defmodule Kernel.QuoteTest do
  end

  test "quote line var" do
-    # DO NOT MOVE THIS LINE
    line = __ENV__.line
-    assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: 26], [1, 2, 3]}
+    assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: line], [1, 2, 3]}
+  end
+
+  test "quote context var" do
+    context = :dynamic
+    assert quote(context: context, do: bar) == {:bar, [], :dynamic}
+
+    assert_raise ArgumentError, fn ->
+      context = "oops"
+      quote(context: context, do: bar)
+    end
+
+    assert_raise ArgumentError, fn ->
+      context = nil
+      quote(context: context, do: bar)
+    end
  end

  test "operator precedence" do
@@ -185,7 +200,7 @@ defmodule Kernel.QuoteTest do

  test "bind quoted" do
    args = [
-      {:=, [], [{:foo, [], Kernel.QuoteTest}, 3]},
+      {:=, [], [{:foo, [line: __ENV__.line + 4], Kernel.QuoteTest}, 3]},
      {:foo, [], Kernel.QuoteTest}
    ]

@@ -276,6 +291,8 @@ end

 # DO NOT MOVE THIS LINE
 defmodule Kernel.QuoteTest.Errors do
+  def line, do: __ENV__.line + 4
+
  defmacro defraise do
    quote location: :keep do
      def will_raise(_a, _b), do: raise("oops")
@@ -294,6 +311,7 @@ defmodule Kernel.QuoteTest.ErrorsTest do
  # Defines the add function
  defraise()

+  @line line()
  test "inside function error" do
    try do
      will_raise(:a, :b)
@@ -301,12 +319,13 @@ defmodule Kernel.QuoteTest.ErrorsTest do
      RuntimeError ->
        mod = Kernel.QuoteTest.ErrorsTest
        file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
-        assert [{^mod, :will_raise, 2, [file: ^file, line: 281]} | _] = __STACKTRACE__
+        assert [{^mod, :will_raise, 2, [file: ^file, line: @line]} | _] = __STACKTRACE__
    else
      _ -> flunk("expected failure")
    end
  end

+  @line __ENV__.line + 3
  test "outside function error" do
    try do
      will_raise()
@@ -314,7 +333,7 @@ defmodule Kernel.QuoteTest.ErrorsTest do
      RuntimeError ->
        mod = Kernel.QuoteTest.ErrorsTest
        file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
-        assert [{^mod, _, _, [file: ^file, line: 312]} | _] = __STACKTRACE__
+        assert [{^mod, _, _, [file: ^file, line: @line]} | _] = __STACKTRACE__
    else
      _ -> flunk("expected failure")
    end
@@ -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"]
@@ -52,5 +52,20 @@ defmodule Kernel.SpecialFormsTest do
        :otherwise -> :also_good
      end
    end
+
+    def false_fun(), do: false
+
+    test "cond_clause error keeps line number in stacktrace" do
+      try do
+        cond do
+          false_fun() -> :ok
+        end
+      rescue
+        _ ->
+          assert [{Kernel.SpecialFormsTest, _, _, meta} | _] = __STACKTRACE__
+          assert meta[:file]
+          assert meta[:line]
+      end
+    end
  end
 end
@@ -578,6 +578,23 @@ defmodule Kernel.WarningTest do
    purge(Sample)
  end

+  test "duplicate map keys" do
+    output =
+      capture_err(fn ->
+        defmodule DuplicateMapKeys do
+          assert %{a: :b, a: :c} == %{a: :c}
+          assert %{m: :n, m: :o, m: :p} == %{m: :p}
+          assert %{1 => 2, 1 => 3} == %{1 => 3}
+        end
+      end)
+
+    assert output =~ "key :a will be overridden in map"
+    assert output =~ "key :m will be overridden in map"
+    assert output =~ "key 1 will be overridden in map"
+
+    assert map_size(%{System.unique_integer() => 1, System.unique_integer() => 2}) == 2
+  end
+
  test "unused guard" do
    assert capture_err(fn ->
             Code.eval_string("""
@@ -903,7 +920,7 @@ defmodule Kernel.WarningTest do
    purge(Sample)
  end

-  test "badarg warning" do
+  test "eval failure warning" do
    assert capture_err(fn ->
             assert_raise ArgumentError, fn ->
               Code.eval_string("""
@@ -912,7 +929,15 @@ defmodule Kernel.WarningTest do
               end
               """)
             end
-           end) =~ "this expression will fail with ArgumentError"
+           end) =~ ~r"this expression will fail with ArgumentError\n.*nofile:2"
+
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Sample do
+               def foo, do: 1 + nil
+             end
+             """)
+           end) =~ ~r"this expression will fail with ArithmeticError\n.*nofile:2"
  after
    purge([Sample])
  end
@@ -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)
@@ -23,17 +23,34 @@ defmodule Module.CheckerTest do
          @deprecated "oops"
          def e, do: :ok
        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          @callback f() :: :ok
+        end
+        """,
+        "c.ex" => """
+        defmodule C do
+          @macrocallback g() :: :ok
+        end
        """
      }

      modules = compile(files)
-      contents = read_chunk(modules[A])

-      assert contents.exports == [
+      assert read_chunk(modules[A]).exports == [
               {{:c, 0}, %{deprecated_reason: nil, kind: :def}},
               {{:d, 0}, %{deprecated_reason: nil, kind: :defmacro}},
               {{:e, 0}, %{deprecated_reason: "oops", kind: :def}}
             ]
+
+      assert read_chunk(modules[B]).exports == [
+               {{:behaviour_info, 1}, %{deprecated_reason: nil, kind: :def}}
+             ]
+
+      assert read_chunk(modules[C]).exports == [
+               {{:behaviour_info, 1}, %{deprecated_reason: nil, kind: :def}}
+             ]
    end
  end

@@ -60,6 +77,28 @@ defmodule Module.CheckerTest do
      assert_warnings(files, warning)
    end

+    test "handles built in functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: Kernel.module_info()
+          def b, do: Kernel.module_info(:functions)
+          def c, do: Kernel.__info__(:functions)
+          def d, do: GenServer.behaviour_info(:callbacks)
+          def e, do: Kernel.behaviour_info(:callbacks)
+        end
+        """
+      }
+
+      warning = """
+      warning: Kernel.behaviour_info/1 is undefined or private
+        a.ex:6: A.e/0
+
+      """
+
+      assert_warnings(files, warning)
+    end
+
    test "handles module body conditionals" do
      files = %{
        "a.ex" => """
@@ -674,7 +713,7 @@ defmodule Module.CheckerTest do
      }

      warning = """
-      warning: function clause will never match, found incompatibility:
+      warning: incompatible types:

          integer() !~ binary()

@@ -710,7 +749,7 @@ defmodule Module.CheckerTest do
      }

      warning = """
-      warning: function clause will never match, found incompatibility:
+      warning: incompatible types:

          integer() !~ binary()

@@ -746,7 +785,7 @@ defmodule Module.CheckerTest do
      }

      warning = """
-      warning: function clause will never match, found incompatibility:
+      warning: incompatible types:

          {var0} !~ var0

@@ -777,7 +816,7 @@ defmodule Module.CheckerTest do
      }

      warning = """
-      warning: function clause will never match, found incompatibility:
+      warning: incompatible types:

          integer() !~ binary()

@@ -813,7 +852,7 @@ defmodule Module.CheckerTest do
      }

      warning = """
-      warning: function clause will never match, found incompatibility:
+      warning: incompatible types:

          integer() !~ binary()

@@ -225,6 +225,11 @@ defmodule Module.Types.PatternTest do
    assert {:ok, :dynamic, context} = quoted_guard([x], elem(x, 0))
    assert Types.lift_type({:var, 0}, context) == :tuple

+    assert {:ok, {:atom, true}, context} = quoted_guard([], true)
+    assert {:ok, {:atom, false}, context} = quoted_guard([], false)
+    assert {:ok, {:atom, :fail}, context} = quoted_guard([], :fail)
+    assert {:ok, :boolean, context} = quoted_guard([], is_atom(true or :fail))
+
    assert {:error, {_, {:unable_unify, :tuple, :boolean, _, _}, _}} =
             quoted_guard([x], is_tuple(x) and is_boolean(x))
  end
@@ -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}]}

@@ -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]
@@ -338,7 +338,7 @@ defmodule ExUnit.Formatter do
            {:match, pins},
            formatter,
            padding_size + 5,
-            width - 5
+            width
          )

        [
@@ -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

@@ -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
@@ -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
@@ -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
@@ -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
@@ -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)"]
@@ -37,10 +37,10 @@ defmodule Mix.CLI do
    file = System.get_env("MIX_EXS") || "mix.exs"

    if File.regular?(file) do
-      old_value = Code.get_compiler_option(:no_warn_undefined)
+      old_undefined = Code.get_compiler_option(:no_warn_undefined)
      Code.put_compiler_option(:no_warn_undefined, :all)
      Code.compile_file(file)
-      Code.put_compiler_option(:no_warn_undefined, old_value)
+      Code.put_compiler_option(:no_warn_undefined, old_undefined)
    end
  end

@@ -18,7 +18,7 @@ defmodule Mix.Generator do

      iex> Mix.Generator.create_file(".gitignore", "_build\ndeps\n")
      * creating .gitignore
-      :ok
+      true

  """
  @spec create_file(Path.t(), iodata, keyword) :: boolean()
@@ -48,7 +48,7 @@ defmodule Mix.Generator do

      iex> Mix.Generator.create_directory("path/to/dir")
      * creating path/to/dir
-      :ok
+      true

  """
  @spec create_directory(Path.t(), keyword) :: true
@@ -73,7 +73,7 @@ defmodule Mix.Generator do

      iex> Mix.Generator.copy_file("source/gitignore", ".gitignore", "_build\ndeps\n")
      * creating .gitignore
-      :ok
+      true

  """
  @doc since: "1.9.0"
@@ -99,7 +99,7 @@ defmodule Mix.Generator do

      iex> Mix.Generator.copy_template("source/gitignore", ".gitignore", [project_path: path])
      * creating .gitignore
-      :ok
+      true

  """
  @doc since: "1.9.0"
@@ -721,15 +721,17 @@ defmodule Mix.Project do

      {new_proj, file} =
        if File.regular?(file) do
+          old_undefined = Code.get_compiler_option(:no_warn_undefined)
+
          try do
-            Code.compiler_options(relative_paths: false)
+            Code.compiler_options(relative_paths: false, no_warn_undefined: :all)
            _ = Code.compile_file(file)
            get()
          else
            ^old_proj -> Mix.raise("Could not find a Mix project at #{file}")
            new_proj -> {new_proj, file}
          after
-            Code.compiler_options(relative_paths: true)
+            Code.compiler_options(relative_paths: true, no_warn_undefined: old_undefined)
          end
        else
          push(nil, file, app)
@@ -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)
@@ -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
@@ -672,9 +672,10 @@ defmodule Mix.Release do

  def copy_erts(release) do
    destination = Path.join(release.path, "erts-#{release.erts_version}")
+    erts_source_contents = File.ls!(release.erts_source)
    File.mkdir_p!(destination)

-    for dir <- ~w(bin include lib src) do
+    for dir <- ~w(bin include lib src), dir in erts_source_contents do
      source = Path.join(release.erts_source, dir)
      target = Path.join(destination, dir)
      File.cp_r!(source, target, fn _, _ -> false end)
@@ -1075,14 +1075,20 @@ defmodule Mix.Tasks.Release do
        [Path.join("lib", "#{name}-#{vsn}") | acc]
      end)

+    erts_dir =
+      case release.erts_source do
+        nil -> []
+        _ -> ["erts-#{release.erts_version}"]
+      end
+
    release_files =
      for basename <- File.ls!(Path.join(release.path, "releases")),
          not File.dir?(Path.join([release.path, "releases", basename])),
          do: Path.join("releases", basename)

    dirs =
-      ["bin", Path.join("releases", release.version), "erts-#{release.erts_version}"] ++
-        lib_dirs ++ release_files
+      ["bin", Path.join("releases", release.version)] ++
+        erts_dir ++ lib_dirs ++ release_files

    files =
      dirs
@@ -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 (
@@ -229,15 +229,17 @@ defmodule Mix.Tasks.Xref do
  end

  # Mod.fun(...)
-  defp walk_expr({{:., meta, [module, fun]}, _, args}, state)
+  defp walk_expr({{:., _, [module, fun]}, meta, args}, state)
       when is_atom(module) and is_atom(fun) do
-    add_call(module, fun, length(args), meta, state)
+    state = add_call(module, fun, length(args), meta, state)
+    walk_expr(args, state)
  end

  # %Module{...}
  defp walk_expr({:%, meta, [module, {:%{}, _meta, args}]}, state)
       when is_atom(module) and is_list(args) do
-    add_call(module, :__struct__, 0, meta, state)
+    state = add_call(module, :__struct__, 0, meta, state)
+    walk_expr(args, state)
  end

  # Function call
@@ -208,6 +208,34 @@ defmodule Mix.Tasks.ReleaseTest do
        end)
      end)
    end
+
+    test "without ERTS when a previous build included ERTS" do
+      in_fixture("release_test", fn ->
+        config = [releases: [demo: [include_erts: false, steps: [:assemble, :tar]]]]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          root = Path.absname("_build/#{Mix.env()}/rel/demo")
+
+          erts_dir_from_previous_build =
+            Path.absname("_build/#{Mix.env()}/rel/demo/erts-#{@erts_version}")
+
+          File.mkdir_p!(erts_dir_from_previous_build)
+
+          Mix.Task.run("release")
+          tar_path = Path.expand(Path.join([root, "..", "..", "demo-0.1.0.tar.gz"]))
+          message = "* building #{tar_path}"
+          assert_received {:mix_shell, :info, [^message]}
+          assert File.exists?(tar_path)
+
+          {:ok, files} = String.to_charlist(tar_path) |> :erl_tar.table([:compressed])
+          files = Enum.map(files, &to_string/1)
+
+          assert "bin/demo" in files
+          refute Enum.any?(files, &(&1 =~ "erts"))
+          refute Enum.any?(files, &(&1 =~ "stdlib"))
+        end)
+      end)
+    end
  end

  test "assembles a bootable release with ERTS" do
@@ -486,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")
Author	SHA1	Message	Date
José Valim	51c95b6000	Release v1.10.1	2020-02-10 12:42:26 +01:00
José Valim	12917b00e5	Unpack extra guards from with matches, closes #9801	2020-02-09 18:15:43 +01:00
Łukasz Jan Niemier	ab9ecf2d7f	fix(logger): use correct return value from report_cb/2 (#9798 ) Earlier it assumed that the return type is the same as in `report_cb/1` which is not true. `report_cb/1` returns format string and data while `report_cb/2` returns already formatted string.	2020-02-09 09:35:02 +01:00
José Valim	eca809285e	Ensure assert_received still produces valid exceptions, closes #9799	2020-02-09 09:32:40 +01:00
José Valim	8e71e65aae	Fix typo	2020-02-08 08:31:09 +01:00
José Valim	c3a27be073	Do not imply nil is caused by Access	2020-02-08 01:58:44 +01:00
José Valim	e10f9fb6fe	Revert "Emit warnings for unused match vars in assertions, closes #9787 " Revert it as we may have false positives in v1.10. We are still keeping it on master. This reverts commit `696bad8de1`.	2020-02-06 20:26:29 +01:00
José Valim	f66ffd0733	Add missing :erlang.size/1 guard, closes #9789	2020-02-06 18:45:01 +01:00
José Valim	696bad8de1	Emit warnings for unused match vars in assertions, closes #9787	2020-02-06 18:35:21 +01:00
Joel C	96c8e31410	Quote variables in cli_bat_text install section (#9780 ) This allows the release batch script to be run in a path that includes spaces.	2020-02-04 14:45:46 +01:00
José Valim	70be440359	Only warn for commas at the end of words	2020-02-04 13:24:50 +01:00
José Valim	c6d6683225	Add tests for timer and interval with infinity	2020-02-03 12:41:54 +01:00
José Valim	db2504eca6	Do not emit invalid code when formatting assocs in maps, closes #9771	2020-02-01 11:18:42 +01:00
José Valim	98c3f5c602	Do not validate line in quote (moved to v1.11)	2020-01-31 11:23:25 +01:00
Akash Hiremath	db4684b2f5	Fix logger truncate for multi-byte characters (#9767 )	2020-01-31 10:44:45 +01:00
José Valim	f3f65e4cd1	No longer rebroadcast messages as this is taken care by Erlang's logger Closes #9765.	2020-01-30 17:02:43 +01:00
Piotr Szmielew	5331174934	Allow using remote or rpc with compile_env Signed-off-by: José Valim <jose.valim@dashbit.co>	2020-01-30 12:05:47 +01:00
Devon Estes	f4f2be67d7	Fix docs for compiler tracing events (#9760 ) The `local_function` event is a tuple with four elements, not five.	2020-01-30 11:44:12 +01:00
Theo Dowling	686daadaaa	Fix typo in CHANGELOG (#9757 )	2020-01-28 07:37:53 +01:00
José Valim	6e8563e930	Add space to quote error message	2020-01-27 12:50:23 +01:00
José Valim	65be24a8c2	CHANGELOG fixes	2020-01-27 10:24:23 +01:00
José Valim	5bd7a90864	Release v1.10	2020-01-27 10:09:33 +01:00
Deniz Adrian	831046fcb7	Ensure ERTS is not copied into release (#9752 ) The default behaviour when starting a new mix project is to `include_erts: true`. If at some point you choose to `include_erts: false`, but have the ERTS artifact hanging around from previous builds, it gets included in future builds, therefore rendering `include_erts: false` broken when running on systems that have built with `include_erts: true` for the same environment. `make_tar/1` currently always tries to include the ERTS artifact into the archive, regardless of our `include_erts` configuration. this fails in 1.9.4 if no previous artifact is present, and seems to be worked around in the current implementation by simply ignoring source directories that don't exist. This adds a regression test for the behaviour by "simulating" an ERTS leftover from a previous build. This also adds logic to not try to include ERTS into archives in the first place when our release is configured with `include_erts: false`.	2020-01-25 15:44:01 +01:00
José Valim	6c44feae2f	Update CHANGELOG	2020-01-24 19:23:51 +01:00
José Valim	35eef87590	Allow file, line and context to be dynamically set on quote, closes #9721	2020-01-23 22:49:31 +01:00
Eric Meadows-Jönsson	fa091c6bd9	Only error for duplicate map keys in matches (#9748 ) In matches we will error: %{a: :b, a: :c} = %{a: :b} In normal expressions we will only warn: %{a: :b, a: :c}	2020-01-23 20:29:24 +01:00
José Valim	a561f81539	Update return types in docs for Mix.Generator functions, closes #9749	2020-01-23 14:40:07 +01:00
José Valim	739c1b6292	Keep existing APIs for min/max/min_by/max_by	2020-01-17 12:54:11 +01:00
Fernando Tapia Rico	3e1e6ddf8a	Update Library Guidelines.md (#9739 )	2020-01-15 19:00:43 +01:00
José Valim	ccb8c5a2e7	Add a new anti-pattern section to library guidelines	2020-01-15 17:55:56 +01:00
Eric Meadows-Jönsson	07e580cf17	Keep line number in cond_clause error (#9730 )	2020-01-14 17:54:40 +01:00
Jason Axelson	1f9f713d9c	Document Mix.Config.persist soft deprecation (#9722 )	2020-01-13 15:51:25 +01:00
José Valim	9814a4cd61	Do not expand interpolation twice, closes #9709	2020-01-12 17:22:45 +01:00
José Valim	3dfdd80dff	Make sure to traverse args in xref	2020-01-12 16:25:13 +01:00
José Valim	0fdc7510b8	Remove guard checks on is_odd/is_even as those are tested in defguard, closes #9700	2020-01-12 16:00:12 +01:00
Eric Meadows-Jönsson	0e8873238d	Do not warn for functions generated by Erlang compiler (#9713 )	2020-01-12 15:42:54 +01:00
Eric Meadows-Jönsson	ba02eb90a0	Allow any type on the RHS of or/2 (#9706 ) Closes #9704.	2020-01-11 12:19:29 +01:00
Eric Meadows-Jönsson	fdc7716bf3	Improve type check error message (#9705 ) A type error may not always cause a clause to fail. Related to #9700.	2020-01-11 12:19:29 +01:00
José Valim	a050c00fbc	Use meta on rewrites, closes #9714	2020-01-11 12:17:43 +01:00
Bram Verburg	d395c3e3cf	Update CHANGELOG.md (#9708 )	2020-01-09 12:28:17 +01:00
Tobiasz Małecki	c3e903f339	Fix mix.release raising error when src is missing in erts_source (#9703 )	2020-01-09 09:57:03 +01:00
José Valim	452ba40855	Update CHANGELOG	2020-01-08 16:56:36 +01:00
José Valim	8854492cc5	Also remove undefined warnings when loading projects outside the CLI	2020-01-08 11:52:26 +01:00
José Valim	105770cfa0	Release v1.10.0-rc.0	2020-01-07 15:10:04 +01:00
José Valim	28b053a122	Prepare v1.10 release	2020-01-07 15:03:35 +01:00