Release v1.4.3

Signed-off-by: José Valim <jose.valim@plataformatec.com.br>

.cirrus.yml

@@ -1,165 +0,0 @@
-env:
-  CIRRUS_CLONE_DEPTH: 50
-  ELIXIR_ASSERT_TIMEOUT: 2000
-  ELIXIRC_OPTS: "--warnings-as-errors"
-  ERLC_OPTS: "+warnings_as_errors"
-  LANG: C.UTF-8
-
-test_template: &DEFAULT_TEST_SETTINGS
-  # don't cancel the task execution if it's master or a release branch
-  auto_cancellation: $CIRRUS_BRANCH != 'master' && $CIRRUS_BRANCH !=~ 'v\d+\.\d+.*'
-
-test_linux_task:
-  <<: *DEFAULT_TEST_SETTINGS
-
-  container:
-    image: buildpack-deps:trusty
-    cpu: 8
-    memory: 1536Mi
-
-  env:
-    PATH: "${CIRRUS_WORKING_DIR}/otp/bin:${PATH}"
-
-  matrix:
-    - name: Linux, ${OTP_RELEASE}, Ubuntu 14.04
-      alias: Linux Stable
-      matrix:
-        - env:
-            CHECK_POSIX_COMPLIANT: true
-            CHECK_REPRODUCIBLE: true
-            OTP_RELEASE: OTP-23.0
-        - env:
-            OTP_RELEASE: OTP-22.3
-        - env:
-            OTP_RELEASE: OTP-22.0
-        - env:
-            OTP_RELEASE: OTP-21.3.8
-        - env:
-            OTP_RELEASE: OTP-21.0
-
-    - name: Linux, OTP-${OTP_RELEASE}, development, Ubuntu 14.04
-      alias: Linux Development
-      allow_failures: true
-      skip_notifications: true
-      depends_on:
-        - Linux Stable
-        - FreeBSD Stable
-      matrix:
-        - env:
-            OTP_RELEASE: master
-        - env:
-            OTP_RELEASE: maint
-
-  install_script:
-    - wget -O otp.tar.gz https://repo.hex.pm/builds/otp/ubuntu-14.04/${OTP_RELEASE}.tar.gz
-    - mkdir -p otp
-    - tar zxf otp.tar.gz -C otp --strip-components=1
-    - otp/Install -minimal ${CIRRUS_WORKING_DIR}/otp
-    - rm -rf .git
-    - make compile
-
-  build_info_script: bin/elixir --version
-
-  test_formatted_script:
-    - make test_formatted &&
-      echo "All Elixir source code files are properly formatted."
-
-  dialyzer_script: dialyzer -pa lib/elixir/ebin --build_plt --output_plt elixir.plt --apps lib/elixir/ebin/elixir.beam lib/elixir/ebin/Elixir.Kernel.beam
-
-  test_erlang_script: make test_erlang
-
-  test_elixir_script: make test_elixir
-
-  check_posix_compliant_script: |
-    if [ -n "$CHECK_POSIX_COMPLIANT" ]; then
-      apt update
-      apt install -y shellcheck
-      shellcheck -e SC2039,2086 bin/elixir && echo "bin/elixir is POSIX compliant"
-      shellcheck bin/elixirc && echo "bin/elixirc is POSIX compliant"
-      shellcheck bin/iex && echo "bin/iex is POSIX compliant"
-    else
-      echo "The format of the shell scripts is only checked in the last stable Erlang/OTP version."
-    fi
-
-  check_reproducible_script: |
-    if [ -n "$CHECK_REPRODUCIBLE" ]; then
-      make check_reproducible
-    else
-      echo "The reproducibility of the build is only checked in the last stable Erlang/OTP version."
-    fi
-
-
-test_windows_task:
-  <<: *DEFAULT_TEST_SETTINGS
-
-  name: Windows, OTP-${OTP_RELEASE}, Windows Server 2019
-  alias: Windows Stable
-
-  matrix:
-    - env:
-        OS_VERSION: 2019
-        OTP_RELEASE: 22.0
-
-    - env:
-        OS_VERSION: 2019
-        OTP_RELEASE: 21.0.1
-
-  windows_container:
-    image: fertapric/elixir-ci:otp-win64-${OTP_RELEASE}
-    os_version: ${OS_VERSION}
-    cpu: 4
-    memory: 6GB
-
-  install_script:
-    - rmdir /s /q .git
-    - make compile
-
-  build_info_script: bin/elixir --version
-
-  test_formatted_script:
-    - make test_formatted &&
-      echo "All Elixir source code files are properly formatted."
-
-  test_erlang_script: make --keep-going test_erlang
-
-  test_elixir_script: make --keep-going test_elixir
-
-
-test_freebsd_task:
-  <<: *DEFAULT_TEST_SETTINGS
-
-  name: FreeBSD 12.1
-  alias: FreeBSD Stable
-
-  freebsd_instance:
-    image_family: freebsd-12-1
-    cpu: 8
-    memory: 7424Mi
-
-  env:
-    CHECK_REPRODUCIBLE: true
-    LC_ALL: en_US.UTF-8
-
-  install_script:
-    - pkg install -y erlang git gmake
-    - rm -rf .git
-    - gmake compile
-
-  build_info_script: bin/elixir --version
-
-  test_formatted_script:
-    - gmake test_formatted &&
-      echo "All Elixir source code files are properly formatted."
-
-  dialyzer_script: dialyzer -pa lib/elixir/ebin --build_plt --output_plt elixir.plt --apps lib/elixir/ebin/elixir.beam lib/elixir/ebin/Elixir.Kernel.beam
-
-  test_erlang_script: gmake test_erlang
-
-  test_elixir_script: gmake test_elixir
-
-  check_reproducible_script: |
-    if [ -n "$CHECK_REPRODUCIBLE" ]; then
-      gmake check_reproducible
-    else
-      echo "The reproducibility of the build is only checked in the last stable Erlang/OTP version."
-    fi

.formatter.exs

@@ -1,17 +0,0 @@
-[
-  inputs: [
-    "lib/*/{lib,unicode,test}/**/*.{ex,exs}",
-    "lib/*/mix.exs"
-  ],
-
-  locals_without_parens: [
-    # Formatter tests
-    assert_format: 2,
-    assert_format: 3,
-    assert_same: 1,
-    assert_same: 2,
-
-    # Errors tests
-    assert_eval_raise: 3
-  ]
-]

.github/ISSUE_TEMPLATE.md

@@ -1,20 +0,0 @@
-### Precheck
-
-* Do not use the issue tracker for help or support (try Elixir Forum, Stack Overflow, IRC, etc.)
-* For proposing a new feature, please start a discussion on the Elixir Core mailing list: https://groups.google.com/group/elixir-lang-core
-* For bugs, do a quick search and make sure the bug has not yet been reported
-* Please disclose security vulnerabilities privately at elixir-security@googlegroups.com
-* Finally, be nice and have fun!
-
-### Environment
-
-* Elixir & Erlang/OTP versions (elixir --version): 
-* Operating system: 
-
-### Current behavior
-
-Include code samples, errors and stacktraces if appropriate.
-
-### Expected behavior
-
-A short description on how you expect the code to behave.

.github/workflows/ci_email.yml

@@ -1,17 +0,0 @@
-on: check_suite
-name: CI email
-jobs:
-  sendEmail:
-    name: Send email
-    runs-on: ubuntu-latest
-    steps:
-    - name: Send email
-      # Source: https://github.com/elixir-lang/elixir-ci
-      uses: docker://fertapric/elixir-ci-email:latest
-      env:
-        APP_NAME: Cirrus CI
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        MAIL_FROM: ci@elixir-lang.org
-        MAIL_HOST: smtp.sendgrid.net
-        MAIL_PASSWORD: ${{ secrets.CI_EMAIL_PASSWORD }}
-        MAIL_USERNAME: ${{ secrets.CI_EMAIL_USERNAME }}

.gitignore

@@ -1,13 +1,17 @@
-/doc/
-/lib/*/ebin/
-/lib/*/_build/
-/lib/*/tmp/
+/doc
+/ebin
+/lib/*/ebin/*
+/lib/*/tmp
+/lib/elixir/src/*_lexer.erl
 /lib/elixir/src/*_parser.erl
-/lib/elixir/test/ebin/
+/lib/elixir/src/elixir.app.src
+/lib/elixir/test/ebin
 /man/elixir.1
 /man/iex.1
+/rel/elixir
 /Docs-v*.zip
 /Precompiled-v*.zip
 /.eunit
+/.release
 .elixir.plt
 erl_crash.dump

.travis.yml

@@ -0,0 +1,20 @@
+language: erlang
+
+otp_release:
+  - 18.0
+  - 18.1
+  - 18.2
+  - 18.3
+  - 19.0
+  - 19.1
+
+sudo: false
+
+script: "make compile && rm -rf .git && make test"
+
+notifications:
+  irc: "irc.freenode.org#elixir-lang"
+  recipients:
+    - jose.valim@plataformatec.com.br
+    - eric.meadows.jonsson@gmail.com
+

CHANGELOG.md

@@ -1,391 +1,333 @@
-# Changelog for Elixir v1.10
+# Changelog for Elixir v1.4
 
-## Support for Erlang/OTP 21+
+Elixir v1.4 brings new features, enhancements and bug fixes into Elixir. The most notable changes are the addition of the `Registry` module and the `Task.async_stream/3` and `Task.async_stream/5` which aid developers in writing concurrent software. Those two features and a couple other improvements are described in detail below followed by the complete list of changes.
 
-Elixir v1.10 requires Erlang/OTP 21+, allowing Elixir to integrate with Erlang/OTP's new logger. Currently, this means that the logger level, logger metadata, as well as all log messages are now shared between Erlang and Elixir APIs.
+## Registry
 
-We will continue improving the relationship between the logging systems in future releases. In particular, we plan to expose all log levels and runtime filtering functionalities available in Erlang directly into Elixir in the next Elixir version.
+The registry is a local, decentralized and scalable key-value process storage:
 
-This release also adds two new guards, `is_struct/1` and `is_map_key/2`, thanks to the strict requirement on Erlang/OTP 21+.
+  * Local because keys and values are only accessible to the current node (opposite to distributed)
+  * Decentralized because there is no single entity responsible for managing the registry
+  * Scalable because performance scales linearly with the addition of more cores upon partitioning
 
-## Releases improvements
+A registry is chosen upon start to have unique or duplicate keys. Every key-value pair is associated to the process registering the key. Keys are automatically removed once the owner process terminates.
 
-Elixir v1.9 introduced releases as a mechanism to package self-contained applications. Elixir v1.10 further improves releases with bug fixes and new enhancements based on feedback we got from the community. The highlights are:
+    iex> Registry.start_link(:unique, MyRegistry)
+    iex> {:ok, _} = Registry.register(MyRegistry, "hello", 1)
+    iex> Registry.lookup(MyRegistry, "hello")
+    [{self(), 1}]
 
-  * Allow the dual boot system of releases to be disabled on environments that are boot-time sensitive, such as embedded devices
+With the registry, developers can provide dynamic process names, module-function dispatch or even a local pubsub system. See the `Registry` documentation for more information.
 
-  * Track and raise if compile-time configuration is set or changes at runtime (more in the next section)
+## Syntax coloring
 
-  * Support for easily adding extra files to releases via overlays
+Elixir v1.4 introduces the ability to syntax color inspected data structures:
 
-  * Allow `RELEASE_DISTRIBUTION` to be set to `none` in order to fully disable it
+    iex> IO.puts inspect([hello: 1, world: "!"], syntax_colors: [atom: :cyan])
+    [hello: 1, world: "!"]
 
-  * Add a built-in `:tar` step that automatically packages releases
+Coloring is done with ANSI colors as specified in the `IO.ANSI` module.
 
-See the full CHANGELOG for more improvements.
+IEx automatically relies on this feature to provide syntax coloring for evaluated shell results. This behaviour can be configured via the `:syntax_colors` coloring option:
 
-## Improvements to sort-based APIs in Enum
+    IEx.configure [colors: [syntax_colors: [atom: :cyan, string: :green]]]
 
-`Enum.sort/1` in Elixir by default sorts from lowest to highest:
+To disable coloring altogether, pass an empty list to `:syntax_colors`.
 
-```elixir
-iex> Enum.sort(["banana", "apple", "pineapple"])
-["apple", "banana", "pineapple"]
-```
+## Calendar
 
-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 v1.3 introduced new calendar types. This release continues evolving the Calendar APIs by adding functions for comparing, adding and calculating the difference between types, retrieve the `day_of_week/1`, check if the current date is a `leap_year?/1` and more.
 
-```elixir
-iex> Enum.sort(["banana", "apple", "pineapple"], &>=/2)
-["pineapple", "banana", "apple"]
-```
+## Task.async_stream
 
-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:
+When there is a need to traverse a collection of items concurrently, Elixir developers often resort to tasks:
 
-```elixir
-iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]])
-[~D[2020-01-01], ~D[2019-12-31]]
-```
+    collection
+    |> Enum.map(&Task.async(SomeMod, :function, [&1]))
+    |> Enum.map(&Task.await/1)
 
-To perform proper semantic comparison for dates, one would also need to pass a custom sorting function:
+While the snippet above works fine in many occasions, for large collections it will spawn and run concurrently as many tasks as there are items in the collection.
 
-```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]]
-```
+`Task.async_stream/3` and `Task.async_stream/5` allows developers to process collections concurrently while controlling the maximum amount of concurrent tasks:
 
-Elixir v1.10 streamlines the sorting functions by introducing both `:asc` and `:desc` shortcuts:
+    collection
+    |> Task.async_stream(SomeMod, :function, [], max_concurrency: System.schedulers_online)
 
-```elixir
-iex> Enum.sort(["banana", "apple", "pineapple"], :asc)
-["apple", "banana", "pineapple"]
-iex> Enum.sort(["banana", "apple", "pineapple"], :desc)
-["pineapple", "banana", "apple"]
-```
+The `Task.async_stream` functions are also lazy, allowing developers to partially consume the stream until a condition is reached. Furthermore, `Task.Supervisor.async_stream/4` and `Task.Supervisor.async_stream/6` can be used to ensure the concurrent tasks are spawned under a given supervisor.
 
-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:
+## Application inference
 
-```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]]
-```
+Mix v1.4 now automatically infers the list of applications that are required on runtime from your dependencies list.
 
-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.
+In previous Mix versions, most of your dependencies had to be added both to your dependencies list and applications list. Here is how a `mix.exs` would look like:
 
-## Tracking of compile-time configuration
+    def application do
+      [applications: [:logger, :plug, :postgrex]]
+    end
 
-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.
+    def deps do
+      [{:plug, "~> 1.2"},
+       {:postgrex, "~> 1.0"}]
+    end
 
-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:
+This was error prone as many developers would not list their dependencies in their applications list.
 
-```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
-```
+Mix v1.4 now automatically infers your applications list as long as you leave the `:applications` key empty. The `mix.exs` above can be rewritten to:
 
-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:
+    def application do
+      [extra_applications: [:logger]]
+    end
 
-    config :my_app, :db_host, "db.production"
+    def deps do
+      [{:plug, "~> 1.2"},
+       {:postgrex, "~> 1.0"}]
+    end
 
-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".
+With the above, Mix will automatically build your application list based on your dependencies. Applications that are part of Erlang or Elixir that are required at runtime, such as `:logger`, must be added to the `:extra_applications` list. All extra applications will be included in the application list.
 
-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:
+Finally, if there is a dependency you don't want to include in the application runtime list, you can do so by specifying the `runtime: false` option:
 
-```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
-```
+    {:distillery, "> 0.0.0", runtime: false}
 
-While this is the preferred approach, there are still two scenarios we need to address:
+We hope this feature provides a more streamlined workflow for developers who are building releases for their Elixir projects.
 
-  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
+## Mix install from SCM
 
-  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
+Mix v1.4 can now install escripts and archives from both Git and Hex, providing you with even more options for distributing Elixir code.
 
-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:
+This makes it possible to distribute CLI applications written in Elixir by publishing a package which builds an escript to Hex. [`ex_doc`](https://hex.pm/packages/ex_doc) has been updated to serve as an example of how to use this new functionality.
 
-```elixir
-@db_host Application.compile_env(:my_app, :db_host, "db.local")
-```
+Simply running:
 
-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.
+    mix escript.install hex ex_doc
 
-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.
+will fetch `ex_doc` and its dependencies, build them, and then install `ex_doc` to `~/.mix/escripts` (by default). After adding `~/.mix/escripts` to your `PATH`, running `ex_doc` is as simple as:
 
-## Compiler tracing
+    ex_doc
 
-This release brings enhancements to the Elixir compiler and adds new capabilities for developers to listen to compilation events.
+You can now also install archives from Hex in this way. Since they are fetched and built on the user's machine, they do not have the same limitations as pre-built archives. However, keep in mind archives run alongside every Mix project, which may lead to conflicts. For this reason, escripts is the preferred format.
 
-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.
+It is also possible to install escripts and archives by providing a Git/GitHub repo. See `mix help escript.install` and `mix help archive.install` for more details.
 
-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.
+## v1.4.3 (2017-05-15)
 
-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.
-
-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
-
-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
-
-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 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.
-
-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:
-
-```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.4 (2020-07-04)
-
-### 1. Bug fixes
-
-#### Elixir
-
-  * [Kernel] Fix a bug where custom types were printed as built-in types
-  * [Kernel] Don't add compile-time dependency on `defdelegate`
-  * [Kernel] Add line numbers to warnings on deprecated imports
-  * [Kernel] Report the correct line number when raising inside a macro
-  * [Task] Include callers in translated Logger metadata for Task
-  * [Task] Fix Task PID and caller in Task Supervisor reports
-
-#### ExUnit
-
-  * [ExUnit.Formatter] Avoid crashes when diffing guards when the pattern does not match
-  * [ExUnit.Formatter] Also blame exceptions that come from linked and trapped exits
-
-#### IEx
-
-  * [IEx.Helpers] Do not crash when printing a type that cannot be code formatted
-
-####  Mix
-
-  * [mix app.start] Fix reading `.app` file located in archives (`.ez` files)
-  * [mix local.hex] Provide more guidance when Hex can't be installed
-  * [mix release] Properly encode config in releases
-
-## v1.10.3 (2020-04-25)
-
-### 1. Bug fixes
-
-#### Elixir
-
-  * [Code] Return `[{mod, bin}]` from `Code.compile_file/2`, `Code.require_file/2`, `Code.load_file/2`
-  * [Code] Make sure the formatter respects newlines before and after module attributes
-  * [Kernel.ParallelCompiler] Fix a bug where the parallel compiler would raise in long compilation cycles
-  * [Kernel.ParallelCompiler] Fix a bug where the parallel compiler would raise if some of the modules being compiled referred to a module that has been loaded directly to memory
-  * [Module] Fix accidental breaking change where bodiless clauses had their body value on `@on_definition` callbacks set to an empty list instead of `nil`
-  * [String] Undeprecate `String.normalize/2` normalize and fix infinite loop caused by certain invalid strings
-
-#### ExUnit
-
-  * [ExUnit.Assertions] Fix pattern matching diff when matching on pinned variables
-  * [ExUnit.Assertions] Fix pattern matching diff when matching variable struct names
-  * [ExUnit.Assertions] Fix pattern matching diff when matching on the binary concat operator (`<>`) and the left side is not a literal string
-  * [ExUnit.Assertions] Fix pattern matching diff when matching on pseudo-vars (`__MODULE__`, `__DIR__`, etc)
-
-#### Mix
-
-  * [mix release] Respect the `:path` option when creating a `:tar` file for releases
-
-## v1.10.2 (2020-02-26)
-
-### 1. Bug fixes
-
-#### Elixir
-
-  * [Macro] Fix a bug where `Macro.to_string/1` would emit invalid code for sigils
-  * [Task] Do not crash `async_stream` monitor if it receives spurious DOWN messages
-
-#### Logger
-
-  * [Logger] Fix a bug where the Logger formatter would fail when handling unknown metadata values
-
-#### Mix
-
-  * [mix compile] Do not write files to disk if `--warnings-as-errors` was given and warnings were emitted
-
-## v1.10.1 (2020-02-10)
-
-### 1. Bug fixes
-
-#### Elixir
-
-  * [Code] Do not emit invalid code when formatting `nil`, `false`, and `true` keys in maps
-  * [Kernel] Ensure `with` clauses properly unpack "implicit guards" (such as matching on the struct name)
-  * [Kernel] Do not warn if commas are used by themselves in `~w`/`~W` sigils
-  * [Kernel] Do not validate the `:line` option in quote (the validation has been moved to v1.11 to give users more time to update their code)
-  * [Module] Ensure the code verifier handles the `:erlang.size/1` guard properly
-
-#### Logger
-
-  * [Logger] Properly handle the `report_cb/2` option from Erlang
-  * [Logger] Fix truncation for multi-byte characters
-  * [Logger] Do not rebroadcast messages from remote nodes as this is now taken care by Erlang's logger
-
-#### ExUnit
-
-  * [ExUnit] Ensure `assert_receive` produces valid exception messages in case of errors
-
-#### Mix
-
-  * [mix release] Make sure the install command (Window specific) works on paths with spaces in the name
-  * [mix release] Allow using `remote` and `rpc` commands with `Application.compile_env/3`
-
-## v1.10.0 (2020-01-27)
+This version includes changes that make Elixir fully compatible with Erlang OTP 20-rc.1.
 
 ### 1. Enhancements
 
 #### Elixir
 
-  * [Application] Add `Application.compile_env/3` and `Application.compile_env!/2` for reading values at compilation time and tracking if they accidentally change during runtime
-  * [Calendar] Allow custom calendar representations in calendar sigils
-  * [Calendar] Add `c:Calendar.parse_time/1`, `c:Calendar.parse_date/1`, `c:Calendar.parse_naive_datetime/1` and `c:Calendar.parse_utc_datetime/1` callbacks to calendar behaviour
-  * [CLI] Add support for `NO_COLOR` environment variable
-  * [Code] Add `:token_metadata` and `:literal_encoder` support to `Code.string_to_quoted/2`
-  * [Code] Add compiler tracing to lift events done by the compiler
-  * [Code] Return `{:error, :unavailable}` in `Code.ensure_compiled/1` if module is in a deadlock
-  * [DateTime] Add `DateTime.now!/2` and `DateTime.shift_zone!/3`
-  * [Enum] Speed up getting one random element from enumerables
-  * [Enum] Add `Enum.frequencies/1`, `Enum.frequencies_by/2`, and `Enum.map_intersperse/2`
-  * [Enum] Allow a sorting function on `Enum.min/max/min_by/max_by`
-  * [Enum] Add `asc/desc` and `compare/1` support to `Enum.sort/2`
-  * [Exception] Add version alongside app names in stacktraces
-  * [Function] Add `Function.identity/1`
-  * [Kernel] Add `Kernel.is_struct/1` and `Kernel.is_map_key/2`
-  * [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
-  * [Module] Add `Module.has_attribute?/2`
-  * [Module] Add `@compile {:no_warn_undefined, mfa_or_module}` to turn off undefined function warnings
-  * [NaiveDateTime] Add `NaiveDateTime.local_now/0`
-  * [Record] Warn if duplicate key is found in record declaration
-  * [String] Update to Unicode 12.1
-  * [StringIO] Add `:encoding` option to StringIO and optimize `get_chars` operation
-
-#### ExUnit
-
-  * [ExUnit.Assertions] Support diffs in pattern matching and in `assert_receive`
-  * [ExUnit.CaptureIO] Supports capturing named devices in asynchronous tests
-
-#### IEx
-
-  * [IEx] Warn on circular file imports when loading default `.iex.exs`
-  * [IEx] Allow customization of the continuation prompt on IEx
+  * [Kernel] Improve compilation time for modules with many clauses
+  * [Map] Warn when attempting to override `__struct__` key
+  * [Regex] Add `recompile/1` and `recompile!/1` to ease transition to OTP 20 for archives and stored regexes
 
 #### Logger
 
-  * [Logger] Allow `start_options` to be configured on Logger's GenEvent
-  * [Logger] Integrate Elixir's Logger with Erlang/OTP 21+'s logger. This means setting up the logger level in Elixir will automatically change the logger level for Erlang and vice-versa
+  * [Logger.Translator] Handle OTP 20 GenServer log messages
 
 #### Mix
 
-  * [mix compile] Add `--profile time` flag to profile compilation steps
-  * [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`
-  * [mix release] Allow configuration reboot to be disabled in releases
-  * [mix test] Add support for simple round-robin test partitioning across multiple machines
-  * [Mix.Project] Add `MIX_DEPS_PATH` environment variable for setting `:deps_path`
-  * [Mix.Project] Add `Mix.Project.deps_scms/1` that returns deps with their SCMs
-  * [Mix.Task] Add `Mix.Task.Compiler.after_compiler/2` callback, to simplify compilers that may need to run something at multiple steps
+  * [mix compile] Recompile projects if OTP version changes
 
 ### 2. Bug fixes
 
-#### EEx
-
-  * [EEx] Ensure multiline do/end with no spaces compile under trim mode
-
 #### Elixir
 
-  * [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
+  * [Kernel] Fix code generation when non-binary bitstrings are in AST
+  * [Record] Properly escape fields passed to `defrecord`
 
 #### ExUnit
 
-  * [ExUnit.Assertions] Fix `assert_receive` and `assert match?` to behave consistently compared `receive` and `match?` when given an invalid macro
+  * [ExUnit.Diff] Do not fail when comparing maps with nil or boolean keys
 
 #### IEx
 
-  * [IEx] Exit IEx session if the group leader exits
-  * [IEx] Allow `pry` to be used in non-tty terminals
+  * [IEx.Helpers] Do not log exits on `IEx.Helpers.c/2` failures
 
 #### Mix
 
-  * [mix compile] Do not filter out warning for external files from diagnostics
-  * [Mix.Project] Ensure user given `:manager` to dependencies has higher precedence than the SCM one
-  * [Mix.Project] Recompile umbrella children when config files change and `mix compile` is called from the umbrella root
-  * [Mix.Task] Always recompile before running tasks from dependencies
-  * [Mix.Task] Ensure project's Logger config is used when running Mix tasks
+  * [mix archive.install] Detect proper path on URLs with query strings
+  * [mix loadpaths] Do not assume all paths in loadpaths exist
 
-### 3. Soft-deprecations (no warnings emitted)
+
+## v1.4.2 (2017-02-16)
+
+### 1. Bug fixes
+
+#### EEx
+
+  * [EEx] Support middle expressions on trim mode
 
 #### Elixir
 
-  * [Code] `compiler_options/0` is deprecated in favor of `compiler_option/1`
+  * [Calendar] Correct typo on Calendar types
+  * [Kernel] Ensure redefined functions point to the proper source
+  * [OptionParser] Add `:allow_nonexistent_atoms` to support unsafe behaviour prior to v1.4
+  * [Stream] Allow consuming multiple items from suspended enumerable in `Stream.transform/3`
+  * [String] Incorporate new grapheme rules in Unicode 9
+
+#### IEx
+
+  * [IEx.Autocomplete] Do not crash on aliases which are not known at compile time
 
 #### 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
+  * [Mix.Umbrella] Ensure umbrella projects can depend on other umbrella projects
+  * [Mix.Archive] Ensure previous archives with `.ez` extension are deleted
 
-### 4. Hard-deprecations
+## v1.4.1 (2017-01-26)
+
+### 1. Bug fixes
 
 #### Elixir
 
-  * [Code] `Code.load_file/2` has been deprecated in favor of `Code.require_file/2` or `Code.compile_file/2`
-  * [Code] `Code.loaded_files/0` and `Code.unload_file/1`  have been deprecated in favor of `Code.required_files/0` and `Code.unrequire_file/1` respectively
-  * [Code] `Code.ensure_compiled?/1` is deprecated in favor of `Code.ensure_compiled/1`
-  * [String] `String.normalize/2` has been deprecated in favor of `:unicode.characters_to_nfc_binary/1` or `:unicode.characters_to_nfd_binary/1` which ship as part of Erlang/OTP 20+
-  * [Supervisor] `Supervisor.Spec.supervise/2` has been deprecated in favor of the new Supervisor child specification
-  * [Supervisor] The `:simple_one_for_one` strategy in `Supervisor` has been deprecated in favor of `DynamicSupervisor`
+  * [Kernel] Remove warning when making private functions overridable
+  * [Path] Ensure `Path.join/1` returns strings for lists of one element
+  * [Regex] Ensure `Regex.escape/1` also escapes `-`
 
-#### Logger
+#### IEx
 
-  * [Logger] `:compile_time_purge_level` application environment configuration has been deprecated in favor of the more general `:compile_time_purge_matching` config
-  * [Logger] Deprecate logging non-chardata values
+  * [IEx] Disable ANSI detection for powershell to avoid false positives
 
 #### Mix
 
-  * [mix compile.xref] This check has been moved into the compiler and has no effect now
-  * [mix xref] `xref` now only tracks dependencies between modules and files, no longer between functions. See "Compilation tracers" to learn more about how to track this information directly
-  * [mix xref deprecations] This check has been moved into the compiler and has no effect now
-  * [mix xref unreachable] This check has been moved into the compiler and has no effect now
+  * [Mix.Make] Run `make clean` for `erlang.mk`
+  * [Mix.Rebar] Support all of rebar3 dependency package declaration
+  * [Mix.Rebar] Only pass overrides from parent to child in Rebar dep
 
-## v1.9
+## v1.4.0 (2017-01-05)
 
-The CHANGELOG for v1.9 releases can be found [in the v1.9 branch](https://github.com/elixir-lang/elixir/blob/v1.9/CHANGELOG.md).
+### 1. Enhancements
+
+#### Elixir
+
+  * [Calendar] Add `Date.compare/2`, `Time.compare/2`, `NaiveDateTime.compare/2` and `DateTime.compare/2`
+  * [Calendar] Support `NaiveDateTime.add/3` and `NaiveDateTime.diff/3` for adding seconds (up to microseconds) as well as the difference between two NaiveDateTimes in seconds (up to microseconds)
+  * [Calendar] Add `Date.leap_year?/1` and `Date.day_of_week/1`
+  * [Calendar] Ensure `Date`, `Time` and `NaiveDateTime` APIs work with any struct that provides the same set of fields as their respective struct. For example, a `NaiveDateTime` can be given to `Date` since it contains a superset of the fields in the `Date` struct
+  * [Calendar] Add `Time.utc_now/0` and `NaiveDateTime.utc_now/0`
+  * [Enum] Add `Enum.map_every/2` that invokes the given function with every nth item
+  * [Enum] Add `min/2`, `max/2`, `min_max/2`, `min_by/3`, `max_by/3`, and `min_max_by/3` that allow a function specifying the default value when the enumerable is empty
+  * [Enum] Introduce `Enum.zip/1` to zip multiple entries at once
+  * [Float] Introduce `Float.ratio/1` that returns a tuple with the numerator and denominator as integers to retrieve the given float
+  * [GenServer] Log warn on default `handle_info/2` implementation
+  * [Inspect] Support syntax coloring via the `:syntax_color` option
+  * [Integer] `Integer.digits/2` now accepts negative integers
+  * [Integer] Add `Integer.mod/2` and `Integer.floor_div/2`
+  * [IO] Add `:label` option to `IO.inspect/2` to help distinguish multiple `IO.inspect/2` calls.
+  * [Kernel] Recognize merge conflict markers in source and provide a readable error message
+  * [Kernel] Warn on unused module attributes
+  * [Kernel] Improve compiler message on unexpected end of line
+  * [Kernel] Raise `BadBooleanError` when a non-boolean is given on the left-hand side of `and`/`or`
+  * [List] Add `List.pop_at/3`
+  * [List] Add `List.myers_difference/2`
+  * [OptionParser] Expand multi-letter aliases in `OptionParser`
+  * [Process] Add `Process.send_after/4`
+  * [Process] Improve error messages on `Process.register/2` errors
+  * [Registry] Add a local, decentralized and scalable key-value process storage
+  * [Stream] Add `Stream.map_every/2` that invokes the given function with every nth item
+  * [Stream] Introduce `Stream.zip/1` to lazily zip multiple entries at once
+  * [String] Update to Unicode 9.0.0
+  * [Task] Add `Task.async_stream/3` and `Task.async_stream/5` as well as the supervised versions `Task.Supervisor.async_stream/4` and `Task.Supervisor.async_stream/6`
+  * [URI] Allow 0 as URI scheme default port
+
+#### ExUnit
+
+  * [ExUnit.Diff] Use red or green background for whitespace-only diffs
+  * [ExUnit.Doctest] Allow inspected structures with multiples lines and unicode characters in the doctest result
+  * [ExUnit.Formatter] Replace lhs/rhs with left/right in the formatter for clarity
+
+#### IEx
+
+  * [IEx.Autocomplete] Stop appending a trailing dot when autocompleting modules in IEx
+  * [IEx.Autocomplete] Support autocompletion for structs
+  * [IEx.Autocomplete] Improve IEx autocomplete to support navigating map atom keys
+  * [IEx.Helpers] `c/1` now compiles in memory by default to avoid common issue where `.beam` files remain at projects root directory
+  * [IEx.Helpers] Add info about protocols in `i/1`
+  * [IEx.Server] Support interrupting IEx evaluation through the Ctrl+G prompt
+
+#### Mix
+
+  * [mix archive] Compress archive files built by `mix archive` as they are now unzipped during installation
+  * [mix archive] Install from SCM
+  * [mix compile] Automatically infer the list of applications for Mix projects
+  * [mix cmd] Add the ability to specify one or more apps in `mix cmd`
+  * [mix deps] Warn if there are non-applications in the `apps` directory for umbrella projects
+  * [mix deps] Add warning for invalid paths on `mix deps.clean`
+  * [mix deps] Add `Mix.Project.apps_paths` that returns the paths to children applications in umbrella projects
+  * [mix deps] Add `MIX_REBAR` environment variable for overriding local rebar
+  * [mix escript] Install from SCM
+  * [mix new] Check directory existence in `mix new` and ask how to proceed if one exists
+  * [mix new] Applications built with the `--sup` flag now have an individual module to work as application callback
+  * [mix test] Add `--formatter` option to `mix test`
+  * [mix xref] Provide "did you mean?" suggestions for `mix xref`
+
+### 2. Bug fixes
+
+#### Elixir
+
+  * [Access] Do not accept nils in `Access.key/1` and `Access.key/2` in favor of explicit default values (or Access.key!/1 if you expect the key to always be available)
+  * [Float] Avoid multiple roundings in `Float.ceil/2`, `Float.floor/2` and `Float.round/2`
+  * [Kernel] Don't crash in `macro_exported?/3` when dealing with Erlang modules
+  * [Kernel] Ensure locals calls are rewritten when calling a local function or macro from inside a module
+  * [Kernel] Annotate the context for variables as zero-arity funs in quotes
+  * [Kernel.SpecialForms] Ensure comprehensions with guards and filters keep proper ordering,
+  * [Kernel.SpecialForms] Produce meaningful warning when with's else clauses have no effect
+  * [Macro] Wrap fn calls in parens in `Macro.to_string/2`
+  * [Macro] Do not print aliases as keys inside keyword lists in `Macro.to_string/2`
+  * [OptionParser] Support options in `OptionParser.to_argv/2` to ensure `:count` switches are correctly encoded
+  * [Stream] Ensure `Stream.take/2` does not consume next element on `:suspend`
+  * [String] Fix infinite recursion in `String.replace_leading/3` and `String.replace_trailing/3` when given an empty string
+  * [Task] Fix `Task.shutdown/1,2` infinite block when task has no monitor
+  * [Task] Ensure task cannot link after parents unlinks
+
+#### ExUnit
+
+  * [ExUnit] Fix a race condition in `assert_receive` where we would assert a message was not received but show it in the list of messages when the message is delivered right after the timeout value
+
+### IEx
+
+  * [IEx.Helpers] Purge consolidated protocols before and after `recompile/0`
+
+### Mix
+
+  * [Mix.Dep] Use `gmake` on FreeBSD instead of `make` when compiling make dependencies
+  * [Mix.Project] Only copy files from source when they're newer than destination (for Windows machines)
+  * [Mix.Task] Ensure non-recursive tasks inside umbrella are reenabled
+
+### 3. Soft deprecations (no warnings emitted)
+
+#### Elixir
+
+  * [Enum] `Enum.partition/2` has been deprecated in favor of `Enum.split_with/2`
+  * [System] Deprecate plural time units in favor of singular ones to align with future Erlang releases
+
+#### ExUnit
+
+  * [ExUnit] Using GenEvent to implement ExUnit formatters is deprecated. Please use the new `GenServer` based formatters instead
+
+### 4. Deprecations
+
+#### Elixir
+
+  * [Access] `Access.key/1` is deprecated due to erratic behaviour for missing keys, please use `Access.key/2` instead with proper default values
+  * [Behaviour] The `Behaviour` module is deprecated. Callbacks may now be defined directly via the `@callback` attribute
+  * [Enum] Deprecate `Enum.uniq/2` in favor of `Enum.uniq_by/2`
+  * [Float] `Float.to_char_list/2` and `Float.to_string/2` are deprecated (use the `:erlang.float_to_list/2` and `:erlang.float_to_binary/2` functions if such conversions are desired)
+  * [Kernel] Deprecate support for making private functions overridable. Overridable functions must always be public as they must be contracts
+  * [Kernel] Warn if variable is used as a function call
+  * [OptionParser] Deprecate aliases with multiple letters, such as `-abc`
+  * [Set] Deprecate the `Set` module
+  * [Stream] Deprecate `Stream.uniq/2` in favor of `Stream.uniq_by/2`
+
+#### IEx
+
+  * [IEx.Helpers] `import_file/2` is deprecated in favor of `import_file_if_available/1`
+
+#### Mix
+
+  * [Mix.Utils] `underscore/1` and `camelize/1` are deprecated in favor of `Macro.underscore/1` and `Macro.camelize/1`
+
+## v1.3
+
+The CHANGELOG for v1.3 releases can be found [in the v1.3 branch](https://github.com/elixir-lang/elixir/blob/v1.3/CHANGELOG.md).

CODE_OF_CONDUCT.md

@@ -39,11 +39,11 @@ If you participate in or contribute to the Elixir ecosystem in any way, you are
 
 Explicit enforcement of the Code of Conduct applies to the official mediums operated by the Elixir project:
 
-* The [official GitHub projects][1] and code reviews.
+* The official GitHub projects and code reviews.
 * The official elixir-lang mailing lists.
-* The **[#elixir-lang][2]** IRC channel on [Freenode][3].
+* The #elixir-lang IRC channel on Freenode.
 
-Other Elixir activities (such as conferences, meetups, and unofficial forums) are encouraged to adopt this Code of Conduct. Such groups must provide their own contact information.
+Other Elixir activities (such as conferences, meetups, and other unofficial forums) are encouraged to adopt this Code of Conduct. Such groups must provide their own contact information.
 
 Project maintainers may remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct.
 
@@ -54,7 +54,3 @@ Instances of abusive, harassing, or otherwise unacceptable behavior may be repor
 ## Acknowledgements
 
 This document was based on the Code of Conduct from the Go project with parts derived from Django's Code of Conduct, Rust's Code of Conduct and the Contributor Covenant.
-
-[1]: https://github.com/elixir-lang/
-[2]: https://webchat.freenode.net/?channels=#elixir-lang
-[3]: https://www.freenode.net

ISSUE_TEMPLATE.md

@@ -0,0 +1,18 @@
+### Precheck
+
+* Do not use the issues tracker for help or support (try Elixir Forum, Stack Overflow, IRC, etc.)
+* For proposing a new feature, please start a discussion on the Elixir Core mailing list
+* For bugs, do a quick search and make sure the bug has not yet been reported
+* Finally, be nice and have fun!
+
+### Environment
+
+* Elixir version (elixir -v):
+* Operating system:
+
+### Current behavior
+
+Include code samples, errors and stacktraces if appropriate.
+
+### Expected behavior
+

LICENSE

@@ -1,176 +1,13 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+Copyright 2012 Plataformatec
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
 
-   1. Definitions.
+      http://www.apache.org/licenses/LICENSE-2.0
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.

Makefile

@@ -1,12 +1,10 @@
+REBAR ?= "$(CURDIR)/rebar"
 PREFIX ?= /usr/local
-TEST_FILES ?= "*_test.exs"
 SHARE_PREFIX ?= $(PREFIX)/share
-MAN_PREFIX ?= $(SHARE_PREFIX)/man
-CANONICAL := v1.10/ # master/ or vMAJOR.MINOR/
-ELIXIRC := bin/elixirc --verbose --ignore-module-conflict $(ELIXIRC_OPTS)
-ERLC := erlc -I lib/elixir/include $(ERLC_OPTS)
+CANONICAL :=
+ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
+ERLC := erlc -I lib/elixir/include
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
-GENERATE_APP := $(CURDIR)/lib/elixir/generate_app.escript
 VERSION := $(strip $(shell cat VERSION))
 Q := @
 LIBDIR := lib
@@ -17,27 +15,29 @@ INSTALL_DATA = $(INSTALL) -m644
 INSTALL_PROGRAM = $(INSTALL) -m755
 GIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))
 GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$head 2> /dev/null | tail -1) )
-SOURCE_DATE_EPOCH_PATH = lib/elixir/tmp/ebin_reproducible
-SOURCE_DATE_EPOCH_FILE = $(SOURCE_DATE_EPOCH_PATH)/SOURCE_DATE_EPOCH
 
-.PHONY: install compile erlang elixir unicode app build_plt clean_plt dialyze test check_reproducible clean clean_residual_files format install_man clean_man docs Docs.zip Precompiled.zip zips
+.PHONY: install compile erlang elixir build_plt clean_plt dialyze test clean install_man clean_man docs Docs.zip Precompiled.zip zips
 .NOTPARALLEL: compile
 
 #==> Functions
 
 define CHECK_ERLANG_RELEASE
-	erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 21)])' -s erlang halt | grep -q '^true'; \
+	$(Q) erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 18)])' -s erlang halt | grep -q '^true'; \
 		if [ $$? != 0 ]; then \
-		  echo "At least Erlang/OTP 21.0 is required to build Elixir"; \
-		  exit 1; \
-		fi
+		   echo "At least Erlang 18.0 is required to build Elixir"; \
+		   exit 1; \
+		fi;
 endef
 
 define APP_TEMPLATE
 $(1): lib/$(1)/ebin/Elixir.$(2).beam lib/$(1)/ebin/$(1).app
 
 lib/$(1)/ebin/$(1).app: lib/$(1)/mix.exs
-	$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run("compile.app", ~w[--compile-path ebin])'
+	$(Q) mkdir -p lib/$(1)/_build/shared/lib/$(1)
+	$(Q) cp -R lib/$(1)/ebin lib/$(1)/_build/shared/lib/$(1)/
+	$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run("compile.app")'
+	$(Q) cp lib/$(1)/_build/shared/lib/$(1)/ebin/$(1).app lib/$(1)/ebin/$(1).app
+	$(Q) rm -rf lib/$(1)/_build
 
 lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1)/lib/*/*.ex) $(wildcard lib/$(1)/lib/*/*/*.ex)
 	@ echo "==> $(1) (compile)"
@@ -45,66 +45,51 @@ lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1
 	$(Q) cd lib/$(1) && ../../$$(ELIXIRC) "lib/**/*.ex" -o ebin
 
 test_$(1): compile $(1)
-	@ echo "==> $(1) (ex_unit)"
-	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/$(TEST_FILES)";
-endef
-
-define WRITE_SOURCE_DATE_EPOCH
-$(shell mkdir -p $(SOURCE_DATE_EPOCH_PATH) && bin/elixir -e \
-  'IO.puts System.build_info()[:date] \
-   |> DateTime.from_iso8601() \
-   |> elem(1) \
-   |> DateTime.to_unix()' > $(SOURCE_DATE_EPOCH_FILE))
-endef
-
-define READ_SOURCE_DATE_EPOCH
-$(strip $(shell cat $(SOURCE_DATE_EPOCH_FILE)))
+	@ echo "==> $(1) (exunit)"
+	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/*_test.exs";
 endef
 
 #==> Compilation tasks
 
-APP := lib/elixir/ebin/elixir.app
-PARSER := lib/elixir/src/elixir_parser.erl
-KERNEL := lib/elixir/ebin/Elixir.Kernel.beam
-UNICODE := lib/elixir/ebin/Elixir.String.Unicode.beam
+KERNEL:=lib/elixir/ebin/Elixir.Kernel.beam
+UNICODE:=lib/elixir/ebin/Elixir.String.Unicode.beam
 
 default: compile
 
-compile: erlang $(APP) elixir
+compile: lib/elixir/src/elixir.app.src erlang elixir
 
-erlang: $(PARSER)
-	$(Q) if [ ! -f $(APP) ]; then $(call CHECK_ERLANG_RELEASE); fi
-	$(Q) cd lib/elixir && mkdir -p ebin && erl -make
+lib/elixir/src/elixir.app.src: src/elixir.app.src
+	$(Q) $(call CHECK_ERLANG_RELEASE)
+	$(Q) rm -rf lib/elixir/src/elixir.app.src
+	$(Q) echo "%% This file is automatically generated from <project_root>/src/elixir.app.src" \
+	                             >lib/elixir/src/elixir.app.src
+	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
 
-$(PARSER): lib/elixir/src/elixir_parser.yrl
-	$(Q) erlc -o $@ +'{verbose,true}' +'{report,true}' $<
+erlang:
+	$(Q) cd lib/elixir && $(REBAR) compile
 
-# Since Mix depends on EEx and EEx depends on Mix,
-# we first compile EEx without the .app file,
-# then Mix and then compile EEx fully
+# Since Mix depends on EEx and EEx depends on
+# Mix, we first compile EEx without the .app
+# file, then mix and then compile EEx fully
 elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit logger eex iex
 
 stdlib: $(KERNEL) VERSION
 $(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
-	$(Q) if [ ! -f $(KERNEL) ]; then \
-		echo "==> bootstrap (compile)"; \
-		$(ERL) -s elixir_compiler bootstrap -s erlang halt; \
+	$(Q) if [ ! -f $(KERNEL) ]; then                  \
+		echo "==> bootstrap (compile)";                 \
+		$(ERL) -s elixir_compiler core -s erlang halt;  \
 	fi
-	$(Q) $(MAKE) unicode
 	@ echo "==> elixir (compile)";
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/kernel.ex" -o ebin;
 	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/**/*.ex" -o ebin;
-	$(Q) $(MAKE) app
-
-app: $(APP)
-$(APP): lib/elixir/src/elixir.app.src lib/elixir/ebin VERSION $(GENERATE_APP)
-	$(Q) $(GENERATE_APP) $< $@ $(VERSION)
+	$(Q) $(MAKE) unicode
+	$(Q) rm -rf lib/elixir/ebin/elixir.app
+	$(Q) cd lib/elixir && $(REBAR) compile
 
 unicode: $(UNICODE)
 $(UNICODE): lib/elixir/unicode/*
 	@ echo "==> unicode (compile)";
-	$(Q) $(ELIXIRC) lib/elixir/unicode/unicode.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC) lib/elixir/unicode/properties.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC) lib/elixir/unicode/tokenizer.ex -o lib/elixir/ebin;
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) unicode/unicode.ex -o ebin;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
 $(eval $(call APP_TEMPLATE,logger,Logger))
@@ -115,77 +100,46 @@ $(eval $(call APP_TEMPLATE,iex,IEx))
 install: compile
 	@ echo "==> elixir (install)"
 	$(Q) for dir in lib/*; do \
-		rm -rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
+		rm -Rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
 		$(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 		$(INSTALL_DATA) $$dir/ebin/* "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 	done
 	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
 	$(Q) $(INSTALL_PROGRAM) $(filter-out %.ps1, $(filter-out %.bat, $(wildcard bin/*))) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
 	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(BINDIR)"
-	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/*; do \
-		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/$(BINDIR)/"; \
+	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/* ; do \
+		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/$(BINDIR)/" ; \
 	done
 	$(MAKE) install_man
 
-check_reproducible: compile
-	$(Q) echo "==> Checking for reproducible builds..."
-	$(Q) rm -rf lib/*/tmp/ebin_reproducible/
-	$(call WRITE_SOURCE_DATE_EPOCH)
-	$(Q) mkdir -p lib/elixir/tmp/ebin_reproducible/ \
-	              lib/eex/tmp/ebin_reproducible/ \
-	              lib/ex_unit/tmp/ebin_reproducible/ \
-	              lib/iex/tmp/ebin_reproducible/ \
-	              lib/logger/tmp/ebin_reproducible/ \
-	              lib/mix/tmp/ebin_reproducible/
-	$(Q) mv lib/elixir/ebin/* lib/elixir/tmp/ebin_reproducible/
-	$(Q) mv lib/eex/ebin/* lib/eex/tmp/ebin_reproducible/
-	$(Q) mv lib/ex_unit/ebin/* lib/ex_unit/tmp/ebin_reproducible/
-	$(Q) mv lib/iex/ebin/* lib/iex/tmp/ebin_reproducible/
-	$(Q) mv lib/logger/ebin/* lib/logger/tmp/ebin_reproducible/
-	$(Q) mv lib/mix/ebin/* lib/mix/tmp/ebin_reproducible/
-	SOURCE_DATE_EPOCH=$(call READ_SOURCE_DATE_EPOCH) $(MAKE) compile
-	$(Q) echo "Diffing..."
-	$(Q) diff -r lib/elixir/ebin/ lib/elixir/tmp/ebin_reproducible/
-	$(Q) diff -r lib/eex/ebin/ lib/eex/tmp/ebin_reproducible/
-	$(Q) diff -r lib/ex_unit/ebin/ lib/ex_unit/tmp/ebin_reproducible/
-	$(Q) diff -r lib/iex/ebin/ lib/iex/tmp/ebin_reproducible/
-	$(Q) diff -r lib/logger/ebin/ lib/logger/tmp/ebin_reproducible/
-	$(Q) diff -r lib/mix/ebin/ lib/mix/tmp/ebin_reproducible/
-	$(Q) echo "Builds are reproducible"
-
 clean:
+	cd lib/elixir && $(REBAR) clean
 	rm -rf ebin
 	rm -rf lib/*/ebin
-	rm -rf $(PARSER)
-	$(Q) $(MAKE) clean_residual_files
+	rm -rf lib/elixir/test/ebin
+	rm -rf lib/*/tmp
+	rm -rf lib/mix/test/fixtures/git_repo
+	rm -rf lib/mix/test/fixtures/deps_on_git_repo
+	rm -rf lib/mix/test/fixtures/git_rebar
+	rm -rf lib/elixir/src/elixir.app.src
+	$(MAKE) clean_man
 
-clean_elixir:
+clean_exbeam:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
 
-clean_residual_files:
-	rm -rf lib/*/_build/
-	rm -rf lib/*/tmp/
-	rm -rf lib/elixir/test/ebin/
-	rm -rf lib/mix/test/fixtures/deps_on_git_repo/
-	rm -rf lib/mix/test/fixtures/git_rebar/
-	rm -rf lib/mix/test/fixtures/git_repo/
-	rm -rf lib/mix/test/fixtures/git_sparse_repo/
-	rm -f erl_crash.dump
-	$(Q) $(MAKE) clean_man
-
-#==> Documentation tasks
+#==> Create Documentation
 
 LOGO_PATH = $(shell test -f ../docs/logo.png && echo "--logo ../docs/logo.png")
-SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}")
+SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}\c")
 DOCS_FORMAT = html
-COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" --main "$(3)" --source-url "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) --output doc/$(2) --canonical "https://hexdocs.pm/$(2)/$(CANONICAL)" --homepage-url "https://elixir-lang.org/docs.html" --formatter "$(DOCS_FORMAT)" $(4)
+COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(2) -n https://hexdocs.pm/$(2)/$(CANONICAL) -p http://elixir-lang.org/docs.html -f "$(DOCS_FORMAT)" $(4)
 
 docs: compile ../ex_doc/bin/ex_doc docs_elixir docs_eex docs_mix docs_iex docs_ex_unit docs_logger
 
 docs_elixir: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (elixir)"
 	$(Q) rm -rf doc/elixir
-	$(call COMPILE_DOCS,Elixir,elixir,Kernel,--config "lib/elixir/docs.exs")
+	$(call COMPILE_DOCS,Elixir,elixir,Kernel,-e "lib/elixir/pages/Behaviours.md" -e "lib/elixir/pages/Guards.md" -e "lib/elixir/pages/Naming Conventions.md" -e "lib/elixir/pages/Operators.md" -e "lib/elixir/pages/Typespecs.md" -e "lib/elixir/pages/Writing Documentation.md")
 
 docs_eex: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (eex)"
@@ -216,57 +170,28 @@ docs_logger: compile ../ex_doc/bin/ex_doc
 	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
 	@ false
 
-#==> Zip tasks
+#==> Zips
 
 Docs.zip: docs
-	rm -f Docs-v$(VERSION).zip
+	rm -rf Docs-v$(VERSION).zip
 	zip -9 -r Docs-v$(VERSION).zip CHANGELOG.md doc NOTICE LICENSE README.md
 	@ echo "Docs file created $(CURDIR)/Docs-v$(VERSION).zip"
 
 Precompiled.zip: build_man compile
-	rm -f Precompiled-v$(VERSION).zip
-	zip -9 -r Precompiled-v$(VERSION).zip bin CHANGELOG.md lib/*/ebin lib/*/lib LICENSE man NOTICE README.md VERSION
+	rm -rf Precompiled-v$(VERSION).zip
+	zip -9 -r Precompiled-v$(VERSION).zip bin CHANGELOG.md lib/*/ebin LICENSE man NOTICE README.md VERSION
 	@ echo "Precompiled file created $(CURDIR)/Precompiled-v$(VERSION).zip"
 
 zips: Precompiled.zip Docs.zip
-	@ echo ""
-	@ echo "### Checksums"
-	@ echo ""
-	@ shasum -a 1 < Precompiled-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Precompiled.zip SHA1:"
-	@ shasum -a 512 < Precompiled-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Precompiled.zip SHA512:"
-	@ shasum -a 1 < Docs-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Docs.zip SHA1:"
-	@ shasum -a 512 < Docs-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Docs.zip SHA512:"
-	@ echo ""
 
-#==> Test tasks
+#==> Tests tasks
 
-# If you modify this task, please update .cirrus.yml accordingly
-test: test_formatted test_erlang test_elixir
-
-test_windows: test test_taskkill
-
-test_taskkill:
-	taskkill //IM erl.exe //F //T //FI "MEMUSAGE gt 0"
-	taskkill //IM epmd.exe //F //T //FI "MEMUSAGE gt 0"
+test: test_erlang test_elixir
 
 TEST_ERL = lib/elixir/test/erlang
 TEST_EBIN = lib/elixir/test/ebin
 TEST_ERLS = $(addprefix $(TEST_EBIN)/, $(addsuffix .beam, $(basename $(notdir $(wildcard $(TEST_ERL)/*.erl)))))
 
-define FORMAT
-	$(Q) if [ "$(OS)" = "Windows_NT" ]; then \
-		cmd //C call ./bin/mix.bat format $(1); \
-	else \
-		bin/elixir bin/mix format $(1); \
-	fi
-endef
-
-format: compile
-	$(call FORMAT)
-
-test_formatted: compile
-	$(call FORMAT,--check-formatted)
-
 test_erlang: compile $(TEST_ERLS)
 	@ echo "==> elixir (eunit)"
 	$(Q) $(ERL) -pa $(TEST_EBIN) -s test_helper test;
@@ -279,12 +204,12 @@ $(TEST_EBIN)/%.beam: $(TEST_ERL)/%.erl
 test_elixir: test_stdlib test_ex_unit test_logger test_mix test_eex test_iex
 
 test_stdlib: compile
-	@ echo "==> elixir (ex_unit)"
+	@ echo "==> elixir (exunit)"
 	$(Q) exec epmd & exit
 	$(Q) if [ "$(OS)" = "Windows_NT" ]; then \
-		cd lib/elixir && cmd //C call ../../bin/elixir.bat -r "test/elixir/test_helper.exs" -pr "test/elixir/**/$(TEST_FILES)"; \
+		cd lib/elixir && cmd //C call ../../bin/elixir.bat -r "test/elixir/test_helper.exs" -pr "test/elixir/**/*_test.exs"; \
 	else \
-		cd lib/elixir && ../../bin/elixir -r "test/elixir/test_helper.exs" -pr "test/elixir/**/$(TEST_FILES)"; \
+		cd lib/elixir && ../../bin/elixir -r "test/elixir/test_helper.exs" -pr "test/elixir/**/*_test.exs"; \
 	fi
 
 #==> Dialyzer tasks
@@ -303,7 +228,7 @@ build_plt: clean_plt $(PLT)
 
 dialyze: compile $(PLT)
 	@ echo "==> Dialyzing Elixir..."
-	$(Q) dialyzer -pa lib/elixir/ebin --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin
+	$(Q) dialyzer --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin
 
 #==> Man page tasks
 
@@ -311,26 +236,24 @@ build_man: man/iex.1 man/elixir.1
 
 man/iex.1:
 	$(Q) cp man/iex.1.in man/iex.1
-	$(Q) sed -i.bak "/{COMMON}/r man/common" man/iex.1
+	$(Q) sed -i.bak "/{COMMON}/r common" man/iex.1
 	$(Q) sed -i.bak "/{COMMON}/d" man/iex.1
-	$(Q) rm -f man/iex.1.bak
+	$(Q) rm man/iex.1.bak
 
 man/elixir.1:
 	$(Q) cp man/elixir.1.in man/elixir.1
-	$(Q) sed -i.bak "/{COMMON}/r man/common" man/elixir.1
+	$(Q) sed -i.bak "/{COMMON}/r common" man/elixir.1
 	$(Q) sed -i.bak "/{COMMON}/d" man/elixir.1
-	$(Q) rm -f man/elixir.1.bak
+	$(Q) rm man/elixir.1.bak
 
 clean_man:
 	rm -f man/elixir.1
-	rm -f man/elixir.1.bak
 	rm -f man/iex.1
-	rm -f man/iex.1.bak
 
 install_man: build_man
-	$(Q) mkdir -p $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(MAN_PREFIX)/man1
+	$(Q) mkdir -p $(DESTDIR)$(SHARE_PREFIX)/man/man1
+	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(SHARE_PREFIX)/man/man1
+	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(SHARE_PREFIX)/man/man1
+	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(SHARE_PREFIX)/man/man1
+	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(SHARE_PREFIX)/man/man1
 	$(MAKE) clean_man

NOTICE

@@ -1,7 +1,9 @@
 LEGAL NOTICE INFORMATION
 ------------------------
 
-All the files in this distribution are copyright to the terms below.
+All the files in this distribution are copyright (c) 2012 Plataformatec
+covered under Elixir's license (see the file LICENSE) except the cases
+below.
 
 == lib/elixir/src/elixir_parser.erl (generated by build scripts)
 
@@ -11,23 +13,7 @@ Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
-    https://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-== All other files
-
-Copyright 2012 Plataformatec
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-   https://www.apache.org/licenses/LICENSE-2.0
+    http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

README.md

@@ -1,35 +1,14 @@
 ![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
 =========
-[![Build status](https://api.cirrus-ci.com/github/elixir-lang/elixir.svg?branch=master)](https://cirrus-ci.com/github/elixir-lang/elixir)
-
-Elixir is a dynamic, functional language designed for building scalable
-and maintainable applications.
+[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master
+"Build Status")](https://travis-ci.org/elixir-lang/elixir)
 
 For more about Elixir, installation and documentation,
-[check Elixir's website](https://elixir-lang.org/).
-
-## Policies
-
-New releases are announced in the [announcement mailing list][8].
-You can subscribe by sending an email to elixir-lang-ann+subscribe@googlegroups.com and replying to the confirmation email.
-
-All security releases [will be tagged with `[security]`][10]. For more information, please read our [Security Policy][9].
-
-All interactions in our official communication channels follow our [Code of Conduct][1].
-
-## Bug reports
-
-For reporting bugs, [visit our issue tracker][2] and follow the steps
-for reporting a new issue. **Please disclose security vulnerabilities
-privately at elixir-security@googlegroups.com**.
+[check Elixir's website](http://elixir-lang.org/).
 
 ## Compiling from source
 
-For the many different ways to install Elixir,
-[see our installation instructions on the website](https://elixir-lang.org/install.html).
-To compile from source, you can follow the steps below.
-
-First, [install Erlang](https://elixir-lang.org/install.html#installing-erlang). Then clone this repository to your machine, compile and test it:
+To run Elixir from source, clone this repository to your machine, compile and test it:
 
 ```sh
 git clone https://github.com/elixir-lang/elixir.git
@@ -45,57 +24,47 @@ If Elixir fails to build (specifically when pulling in a new version via
 `git`), be sure to remove any previous build artifacts by running
 `make clean`, then `make test`.
 
-If tests pass, you can use Interactive Elixir by running `bin/iex` in your terminal.
+If tests pass, you are ready to move on to the [Getting Started guide][1]
+or to try Interactive Elixir by running `bin/iex` in your terminal.
 
-However, if tests fail, it is likely that you have an outdated Erlang/OTP version
-(Elixir requires Erlang/OTP 21.0 or later). You can check your Erlang/OTP version
-by calling `erl` in the command line. You will see some information similar to:
+However, if tests fail, it is likely you have an outdated Erlang version
+(Elixir requires Erlang 18.0 or later). You can check your Erlang version
+by calling `erl` in the command line. You will see some information as follows:
 
-    Erlang/OTP 21 [erts-9.0] [smp:2:2] [async-threads:10] [kernel-poll:false]
+    Erlang/OTP 18 [erts-7.0] [source] [smp:2:2] [async-threads:10] [hipe] [kernel-poll:false]
 
 If you have properly set up your dependencies and tests still fail,
 you may want to open up a bug report, as explained next.
 
-## Proposing new features
+## Bug reports
 
-For proposing new features, please start a discussion in the
-[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
-to argue and explain why a feature is useful and how it will impact the
-codebase and the community.
-
-Once a proposal is accepted, it will be added to [the issue tracker][2].
-The issue tracker focuses on *actionable items* and it holds a list of
-upcoming enhancements and pending bugs. All entries in the tracker are
-tagged for clarity and to ease collaboration.
-
-Features and bug fixes that have already been merged and will be included
-in the next release are marked as "closed" in the issue tracker and are
-added to the [changelog][7].
+For reporting bugs, [visit our issues tracker][2] and follow the steps
+for reporting a new issue. Please disclose security vulnerabilities
+privately at elixir-security@googlegroups.com.
 
 ## Contributing
 
-We welcome everyone to contribute to Elixir. To do so, there are a few
-things you need to know about the code. First, Elixir code is divided
-in applications inside the `lib` folder:
+We welcome everyone to contribute to Elixir and help us tackle existing issues!
+To do so, there are a few things you need to know about the code. First, Elixir
+code is divided in applications inside the `lib` folder:
 
-* `elixir` - Elixir's kernel and standard library
+* `elixir` - Contains Elixir's kernel and stdlib
 
-* `eex` - EEx is the template engine that allows you to embed Elixir
+* `eex` - Template engine that allows you to embed Elixir
 
-* `ex_unit` - ExUnit is a simple test framework that ships with Elixir
+* `ex_unit` - Simple test framework that ships with Elixir
 
-* `iex` - IEx stands for Interactive Elixir: Elixir's interactive shell
+* `iex` - IEx, Elixir's interactive shell
 
-* `logger` - Logger is the built-in logger
+* `logger` - The built-in logger
 
-* `mix` - Mix is Elixir's build tool
+* `mix` - Elixir's build tool
 
 You can run all tests in the root directory with `make test` and you can
-also run tests for a specific framework `make test_#{APPLICATION}`, for example,
-`make test_ex_unit`. If you just changed something in the Elixir's standard
-library, you can run only that portion through `make test_stdlib`.
+also run tests for a specific framework `make test_#{NAME}`, for example,
+`make test_ex_unit`.
 
-If you are changing just one file, you can choose to compile and run tests only
+In case you are changing a single file, you can compile and run tests only
 for that particular file for fast development cycles. For example, if you
 are changing the String module, you can compile it and run its tests as:
 
@@ -104,36 +73,28 @@ bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
 bin/elixir lib/elixir/test/elixir/string_test.exs
 ```
 
-To recompile (including Erlang modules):
-
-```sh
-make compile
-```
-
-After your changes are done, please remember to run `make format` to guarantee
-all files are properly formatted and then run the full suite with
+After your changes are done, please remember to run the full suite with
 `make test`.
 
-If your contribution fails during the bootstrapping of the language,
-you can rebuild the language from scratch with:
-
-```sh
-make clean_elixir compile
-```
-
-Similarly, if you can't get Elixir to compile or the tests to pass after
-updating an existing checkout, run `make clean compile`. You can check
-[the official build status on Cirrus CI](https://cirrus-ci.com/github/elixir-lang/elixir).
-More tasks can be found by reading the [Makefile](Makefile).
+From time to time, your tests may fail in an existing Elixir checkout and
+may require a clean start by running `make clean compile`. You can always
+check [the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
 
 With tests running and passing, you are ready to contribute to Elixir and
 [send a pull request](https://help.github.com/articles/using-pull-requests/).
 We have saved some excellent pull requests we have received in the past in
 case you are looking for some examples:
 
-* [Implement Enum.member? - Pull Request](https://github.com/elixir-lang/elixir/pull/992)
-* [Add String.valid? - Pull Request](https://github.com/elixir-lang/elixir/pull/1058)
-* [Implement capture_io for ExUnit - Pull Request](https://github.com/elixir-lang/elixir/pull/1059)
+* [Implement Enum.member? – Pull Request](https://github.com/elixir-lang/elixir/pull/992)
+* [Add String.valid? – Pull Request](https://github.com/elixir-lang/elixir/pull/1058)
+* [Implement capture_io for ExUnit – Pull Request](https://github.com/elixir-lang/elixir/pull/1059)
+
+We usually keep a list of enhancements and bugs [in the issue tracker][2].
+For proposing new features, please start a discussion in the
+[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
+to argue and explain why a feature is useful and how it will impact the
+codebase and the community. Finally, remember all interactions in our official
+spaces follow our [Code of Conduct][7].
 
 ### Reviewing changes
 
@@ -141,23 +102,15 @@ Once a pull request is sent, the Elixir team will review your changes.
 We outline our process below to clarify the roles of everyone involved.
 
 All pull requests must be approved by two committers before being merged into
-the repository. If any changes are necessary, the team will leave appropriate
-comments requesting changes to the code. Unfortunately we cannot guarantee a
-pull request will be merged, even when modifications are requested, as the Elixir
-team will re-evaluate the contribution as it changes.
-
-Committers may also push style changes directly to your branch. If you would
-rather manage all changes yourself, you can disable "Allow edits from maintainers"
-feature when submitting your pull request.
+the repository. In case any changes are necessary, the team will leave
+appropriate comments requesting changes to the code.
 
 The Elixir team may optionally assign someone to review a pull request.
-If someone is assigned, they must explicitly approve the code before
+In case someone is assigned, they must explicitly approve the code before
 another team member can merge it.
 
-When the review finishes, your pull request will be squashed and merged
-into the repository. If you have carefully organized your commits and
-believe they should be merged without squashing, please mention it in
-a comment.
+When review is completed, your pull request will be squashed and merged
+into the repository.
 
 ## Building documentation
 
@@ -168,45 +121,35 @@ to be installed and built alongside Elixir:
 # After cloning and compiling Elixir, in its parent directory:
 git clone git://github.com/elixir-lang/ex_doc.git
 cd ex_doc && ../elixir/bin/mix do deps.get, compile
+cd ../elixir && make docs
 ```
 
-Now go back to Elixir's root directory and run:
-
-```sh
-make docs                  # to generate HTML pages
-make docs DOCS_FORMAT=epub # to generate EPUB documents
-```
-
-This will produce documentation sets for `elixir`, `eex`, `ex_unit`, `iex`, `logger`,
-and `mix` under the `doc` directory. If you are planning to contribute documentation,
-[please check our best practices for writing documentation](https://hexdocs.pm/elixir/writing-documentation.html).
+This will produce documentation sets for `elixir`, `mix`, etc., under
+the `doc` directory. If you are planning to contribute documentation,
+[please check our best practices for writing documentation](http://elixir-lang.org/docs/stable/elixir/writing-documentation.html).
 
 ## Development links
 
+  * [Elixir Website][1]
   * [Elixir Documentation][6]
   * [Elixir Core Mailing list (development)][3]
-  * [Announcement mailing list][8]
-  * [Code of Conduct][1]
-  * [Issue tracker][2]
-  * [Changelog][7]
-  * [Security Policy][9]
+  * [Issues tracker][2]
+  * [Code of Conduct][7]
   * **[#elixir-lang][4]** on [Freenode][5] IRC
 
-  [1]: CODE_OF_CONDUCT.md
+  [1]: http://elixir-lang.org
   [2]: https://github.com/elixir-lang/elixir/issues
   [3]: https://groups.google.com/group/elixir-lang-core
   [4]: https://webchat.freenode.net/?channels=#elixir-lang
-  [5]: https://www.freenode.net
-  [6]: https://elixir-lang.org/docs.html
-  [7]: CHANGELOG.md
-  [8]: https://groups.google.com/group/elixir-lang-ann
-  [9]: SECURITY.md
-  [10]: https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date
+  [5]: http://www.freenode.net
+  [6]: http://elixir-lang.org/docs.html
+  [7]: CODE_OF_CONDUCT.md
 
 ## License
 
 "Elixir" and the Elixir logo are copyright (c) 2012 Plataformatec.
 
-Elixir source code is released under Apache License 2.0.
+Elixir source code is released under Apache 2 License.
 
-Check [NOTICE](NOTICE) and [LICENSE](LICENSE) files for more information.
+Check [NOTICE](NOTICE) and [LICENSE](LICENSE) files for more
+information.

RELEASE.md

@@ -1,45 +1,43 @@
 # Release process
 
-## Shipping a new version
+## All releases
+
+This document simply outlines the release process:
 
 1. Ensure you are running on the oldest supported Erlang version
 
-2. Update version in /VERSION
+2. Remove all `-dev` extension from versions (see below for all files)
 
-3. Ensure /CHANGELOG.md is updated, versioned and add the current date
+3. Ensure CHANGELOG is updated and add current date
 
-4. Update "Compatibility and Deprecations" if a new OTP version is supported
+4. Commit changes above with title "Release vVERSION" and generate new tag
 
-5. Commit changes above with title "Release vVERSION" and generate a new tag
+5. Run `make clean test` to ensure all tests pass from scratch and the CI is green
 
-6. Run `make clean test` to ensure all tests pass from scratch and the CI is green
+6. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
 
-7. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
+7. Push branch and the new tag
 
-8. Push branch and the new tag
+8. If a new `vMAJOR.MINOR`, create a new branch "vMAJOR.MINOR" and set `CANONICAL=` in Makefile before building docs
 
-9. Publish new zips with `make zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases, and include SHAs+CHANGELOG
+9. Publish new zips with `make zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
 
-10. Add the release to `elixir.csv` (all releases), update `erlang.csv` to the precompiled OTP version, and `_data/elixir-versions.yml` (except for RCs) files in `elixir-lang/elixir-lang.github.com`
+10. Add the release to `elixir.csv` and `_data/elixir-versions.yml` files in `elixir-lang/elixir-lang.github.com`
 
-11. Send an e-mail to elixir-lang-ann@googlegroups.com with title "Elixir vVERSION released". The body should be a link to the Release page on GitHub and the checksums. If it is a security release, prefix the title with the `[security]` tag
+11. After a new `vMAJOR.MINOR`, move back to master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vMAJOR.MINOR+1"
 
-## Creating a new vMAJOR.MINOR branch
+## Places where version is mentioned
 
-### In the new branch
+* VERSION
+* CHANGELOG.md
+* src/elixir.app.src (not lib/elixir/src/elixir.app.src)
 
-1. Set `CANONICAL=` in /Makefile
+## Deprecation policy
 
-2. Update tables in /SECURITY.md and "Compatibility and Deprecations"
+Elixir deprecations happens in 3 steps:
 
-3. Commit "Prepare vMAJOR.MINOR for release"
+  1. The feature is soft-deprecated. It means both CHANGELOG and documentation must list the feature as deprecated but no warning is effectively emitted by running the code. There is no requirement to soft-deprecate a feature.
 
-### Back in master
+  2. The feature is effectively deprecated by emitting warnings on usage. In order to deprecate a feature, the proposed alternative MUST exist for AT LEAST two versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a deprecation warning may only be emitted by Elixir v1.3 or later.
 
-1. Bump /VERSION file
-
-2. Start new /CHANGELOG.md
-
-3. Update tables in /SECURITY.md in "Compatibility and Deprecations"
-
-4. Commit "Start vMAJOR.MINOR+1"
+  3. The feature is removed. This can only happen on major releases. This means deprecated features in Elixir v1.x shall only be removed by Elixir v2.x.

SECURITY.md

@@ -1,23 +0,0 @@
-# Security Policy
-
-## Supported versions
-
-Elixir applies bug fixes only to the latest minor branch. Security patches are available for the last 5 minor branches:
-
-| Elixir version | Support
-| -------------- | ------------------------------
-| 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
-
-## Announcements
-
-New releases are announced in the read-only [announcements mailing list](https://groups.google.com/group/elixir-lang-ann). You can subscribe by sending an email to elixir-lang-ann+subscribe@googlegroups.com and replying to the confirmation email.
-
-All security releases [will be tagged with `[security]`](https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date).
-
-## Reporting a vulnerability
-
-Please disclose security vulnerabilities privately at elixir-security@googlegroups.com

VERSION

@@ -1 +1 @@
-1.10.4
+1.4.3

bin/elixir

@@ -1,58 +1,30 @@
 #!/bin/sh
-set -e
-
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  cat <<USAGE >&2
-Usage: $(basename "$0") [options] [.exs file] [data]
+  echo "Usage: `basename $0` [options] [.exs file] [data]
 
-## General options
+  -v                          Prints version and exits
+  -e COMMAND                  Evaluates the given command (*)
+  -r FILE                     Requires the given files/patterns (*)
+  -S SCRIPT                   Finds and executes the given script in PATH
+  -pr FILE                    Requires the given files/patterns in parallel (*)
+  -pa PATH                    Prepends the given path to Erlang code path (*)
+  -pz PATH                    Appends the given path to Erlang code path (*)
 
-  -e "COMMAND"                 Evaluates the given command (*)
-  -h, --help                   Prints this message and exits
-  -r "FILE"                    Requires the given files/patterns (*)
-  -S SCRIPT                    Finds and executes the given script in \$PATH
-  -pr "FILE"                   Requires the given files/patterns in parallel (*)
-  -pa "PATH"                   Prepends the given path to Erlang code path (*)
-  -pz "PATH"                   Appends the given path to Erlang code path (*)
-  -v, --version                Prints Elixir version and exits
+  --app APP                   Starts the given app and its dependencies (*)
+  --cookie COOKIE             Sets a cookie for this distributed node
+  --detached                  Starts the Erlang VM detached from console
+  --erl SWITCHES              Switches to be passed down to Erlang (*)
+  --hidden                    Makes a hidden node
+  --logger-otp-reports BOOL   Enables or disables OTP reporting
+  --logger-sasl-reports BOOL  Enables or disables SASL reporting
+  --name NAME                 Makes and assigns a name to the distributed node
+  --no-halt                   Does not halt the Erlang VM after execution
+  --sname NAME                Makes and assigns a short name to the distributed node
+  --werl                      Uses Erlang's Windows shell GUI (Windows only)
 
-  --app APP                    Starts the given app and its dependencies (*)
-  --erl "SWITCHES"             Switches to be passed down to Erlang (*)
-  --eval "COMMAND"             Evaluates the given command, same as -e (*)
-  --logger-otp-reports BOOL    Enables or disables OTP reporting
-  --logger-sasl-reports BOOL   Enables or disables SASL reporting
-  --no-halt                    Does not halt the Erlang VM after execution
-  --werl                       Uses Erlang's Windows shell GUI (Windows only)
-
-Options given after the .exs file or -- are passed down to the executed code.
-Options can be passed to the Erlang runtime using \$ELIXIR_ERL_OPTIONS or --erl.
-
-## Distribution options
-
-The following options are related to node distribution.
-
-  --cookie COOKIE              Sets a cookie for this distributed node
-  --hidden                     Makes a hidden node
-  --name NAME                  Makes and assigns a name to the distributed node
-  --rpc-eval NODE "COMMAND"    Evaluates the given command on the given remote node (*)
-  --sname NAME                 Makes and assigns a short name to the distributed node
-
-## Release options
-
-The following options are generally used under releases.
-
-  --boot "FILE"                Uses the given FILE.boot to start the system
-  --boot-var VAR "VALUE"       Makes \$VAR available as VALUE to FILE.boot (*)
-  --erl-config "FILE"          Loads configuration in FILE.config written in Erlang (*)
-  --pipe-to "PIPEDIR" "LOGDIR" Starts the Erlang VM as a named PIPEDIR and LOGDIR
-  --vm-args "FILE"             Passes the contents in file as arguments to the VM
-
---pipe-to starts Elixir detached from console (Unix-like only).
-It will attempt to create PIPEDIR and LOGDIR if they don't exist.
-See run_erl to learn more. To reattach, run: to_erl PIPEDIR.
-
-** Options marked with (*) can be given more than once.
-USAGE
+** Options marked with (*) can be given more than once
+** Options given after the .exs file or -- are passed down to the executed code
+** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS or --erl" >&2
   exit 1
 fi
 
@@ -62,142 +34,70 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 
-# Stores static Erlang arguments and --erl (which is passed as is)
-ERL=""
-
-# Stores erl arguments preserving spaces/quotes (mimics an array)
-erl () {
-  eval "E${E}=\$1"
-  E=$((E + 1))
-}
-
-# Checks if a string starts with prefix. Usage: starts_with "$STRING" "$PREFIX"
-starts_with () {
-  case $1 in
-    "$2"*) true;;
-    *) false;;
-  esac
-}
-
-ERL_EXEC="erl"
 MODE="elixir"
+ERL_EXEC="erl"
+ERL=""
 I=1
-E=0
-LENGTH=$#
-set -- "$@" -extra
 
-while [ $I -le $LENGTH ]; do
+while [ $I -le $# ]; do
   S=1
-  case "$1" in
+  eval "PEEK=\${$I}"
+  case "$PEEK" in
     +iex)
-        set -- "$@" "$1"
         MODE="iex"
         ;;
     +elixirc)
-        set -- "$@" "$1"
         MODE="elixirc"
         ;;
-    -v|--no-halt)
-        set -- "$@" "$1"
+    -v|--compile|--no-halt)
         ;;
-    -e|-r|-pr|-pa|-pz|--app|--eval|--remsh|--dot-iex)
+    -e|-r|-pr|-pa|-pz|--remsh|--app)
         S=2
-        set -- "$@" "$1" "$2"
         ;;
-    --rpc-eval)
-        S=3
-        set -- "$@" "$1" "$2" "$3"
+    --detached|--hidden)
+        ERL="$ERL `echo $PEEK | cut -c 2-`"
         ;;
-    --detached)
-        echo "warning: the --detached option is deprecated" >&2
-        ERL="$ERL -detached"
+    --cookie)
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL -setcookie "$VAL""
         ;;
-    --hidden)
-        ERL="$ERL -hidden"
+    --sname|--name)
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL `echo $PEEK | cut -c 2-` "$VAL""
         ;;
     --logger-otp-reports)
-        S=2
-        if [ "$2" = 'true' ] || [ "$2" = 'false' ]; then
-          ERL="$ERL -logger handle_otp_reports $2"
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        if [ "$VAL" == 'true' ] || [ "$VAL" == 'false' ]; then
+            ERL="$ERL -logger handle_otp_reports "$VAL""
         fi
         ;;
     --logger-sasl-reports)
-        S=2
-        if [ "$2" = 'true' ] || [ "$2" = 'false' ]; then
-          ERL="$ERL -logger handle_sasl_reports $2"
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        if [ "$VAL" == 'true' ] || [ "$VAL" == 'false' ]; then
+            ERL="$ERL -logger handle_sasl_reports "$VAL""
         fi
         ;;
     --erl)
-        S=2
-        ERL="$ERL $2"
-        ;;
-    --cookie)
-        S=2
-        erl "-setcookie"
-        erl "$2"
-        ;;
-    --sname|--name)
-        S=2
-        erl "$(echo "$1" | cut -c 2-)"
-        erl "$2"
-        ;;
-    --erl-config)
-        S=2
-        erl "-config"
-        erl "$2"
-        ;;
-    --vm-args)
-        S=2
-        erl "-args_file"
-        erl "$2"
-        ;;
-    --boot)
-        S=2
-        erl "-boot"
-        erl "$2"
-        ;;
-    --boot-var)
-        S=3
-        erl "-boot_var"
-        erl "$2"
-        erl "$3"
-        ;;
-    --pipe-to)
-        S=3
-        RUN_ERL_PIPE="$2"
-        RUN_ERL_LOG="$3"
-        if [ "$(starts_with "$RUN_ERL_PIPE" "-")" ]; then
-          echo "--pipe-to : PIPEDIR cannot be a switch" >&2 && exit 1
-        elif [ "$(starts_with "$RUN_ERL_LOG" "-")" ]; then
-          echo "--pipe-to : LOGDIR cannot be a switch" >&2 && exit 1
-        fi
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL "$VAL""
         ;;
     --werl)
-        if [ "$OS" = "Windows_NT" ]; then ERL_EXEC="werl"; fi
+        USE_WERL=true
         ;;
     *)
-        while [ $I -le $LENGTH ]; do
-          I=$((I + 1))
-          set -- "$@" "$1"
-          shift
-        done
         break
         ;;
   esac
-
-  I=$((I + S))
-  shift $S
-done
-
-I=$((E - 1))
-while [ $I -ge 0 ]; do
-  eval "VAL=\$E$I"
-  set -- "$VAL" "$@"
-  I=$((I - 1))
+  I=$(expr $I + $S)
 done
 
 SELF=$(readlink_f "$0")
@@ -206,26 +106,21 @@ SCRIPT_PATH=$(dirname "$SELF")
 if [ "$OSTYPE" = "cygwin" ]; then SCRIPT_PATH=$(cygpath -m "$SCRIPT_PATH"); fi
 if [ "$MODE" != "iex" ]; then ERL="-noshell -s elixir start_cli $ERL"; fi
 
-if [ "$OS" != "Windows_NT" ] && [ -z "$NO_COLOR" ]; then
+# Check for terminal support
+if [ "$OS" != "Windows_NT" ]; then
   if test -t 1 -a -t 2; then ERL="-elixir ansi_enabled true $ERL"; fi
 fi
 
-ERTS_BIN=
-set -- "$ERTS_BIN$ERL_EXEC" -pa "$SCRIPT_PATH"/../lib/*/ebin $ELIXIR_ERL_OPTIONS $ERL "$@"
-
-if [ -n "$RUN_ERL_PIPE" ]; then
-  ESCAPED=""
-  for PART in "$@"; do
-    ESCAPED="$ESCAPED $(echo "$PART" | sed 's/[^a-zA-Z0-9_\-\/]/\\&/g')"
-  done
-  mkdir -p "$RUN_ERL_PIPE"
-  mkdir -p "$RUN_ERL_LOG"
-  ERL_EXEC="run_erl"
-  set -- "$ERTS_BIN$ERL_EXEC" -daemon "$RUN_ERL_PIPE/" "$RUN_ERL_LOG/" "$ESCAPED"
+if [ "$OS" = "Windows_NT" ] && [ $USE_WERL ]; then
+    ERL_EXEC="werl"
 fi
 
-if [ -n "$ELIXIR_CLI_DRY_RUN" ]; then
-  echo "$@"
-else
-  exec "$@"
+if [ -z "$ERL_PATH" ]; then
+  if [ -f "$SCRIPT_PATH/../releases/RELEASES" ] && [ -f "$SCRIPT_PATH/erl" ]; then
+    ERL_PATH="$SCRIPT_PATH"/"$ERL_EXEC"
+  else
+    ERL_PATH="$ERL_EXEC"
+  fi
 fi
+
+exec "$ERL_PATH" -pa "$SCRIPT_PATH"/../lib/*/ebin $ELIXIR_ERL_OPTIONS $ERL -extra "$@"

bin/elixir.bat

@@ -1,5 +1,5 @@
 @if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
-setlocal enabledelayedexpansion
+setlocal
 if    ""%1""==""""       goto documentation
 if /I ""%1""==""--help"" goto documentation
 if /I ""%1""==""-h""     goto documentation
@@ -10,155 +10,104 @@ goto parseopts
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo ## General options
+echo   -v                          Prints version and exits
+echo   -e COMMAND                  Evaluates the given command (*)
+echo   -r FILE                     Requires the given files/patterns (*)
+echo   -S SCRIPT                   Finds and executes the given script in PATH
+echo   -pr FILE                    Requires the given files/patterns in parallel (*)
+echo   -pa PATH                    Prepends the given path to Erlang code path (*)
+echo   -pz PATH                    Appends the given path to Erlang code path (*)
 echo.
-echo   -e "COMMAND"                 Evaluates the given command (*)
-echo   -h, --help                   Prints this message and exits
-echo   -r "FILE"                    Requires the given files/patterns (*)
-echo   -S SCRIPT                    Finds and executes the given script in $PATH
-echo   -pr "FILE"                   Requires the given files/patterns in parallel (*)
-echo   -pa "PATH"                   Prepends the given path to Erlang code path (*)
-echo   -pz "PATH"                   Appends the given path to Erlang code path (*)
-echo   -v, --version                Prints Elixir version and exits
+echo   --app APP                   Starts the given app and its dependencies (*)
+echo   --cookie COOKIE             Sets a cookie for this distributed node
+echo   --detached                  Starts the Erlang VM detached from console
+echo   --erl SWITCHES              Switches to be passed down to Erlang (*)
+echo   --hidden                    Makes a hidden node
+echo   --logger-otp-reports BOOL   Enables or disables OTP reporting
+echo   --logger-sasl-reports BOOL  Enables or disables SASL reporting
+echo   --name NAME                 Makes and assigns a name to the distributed node
+echo   --no-halt                   Does not halt the Erlang VM after execution
+echo   --sname NAME                Makes and assigns a short name to the distributed node
+echo   --werl                      Uses Erlang's Windows shell GUI
 echo.
-echo   --app APP                    Starts the given app and its dependencies (*)
-echo   --erl "SWITCHES"             Switches to be passed down to Erlang (*)
-echo   --eval "COMMAND"             Evaluates the given command, same as -e (*)
-echo   --logger-otp-reports BOOL    Enables or disables OTP reporting
-echo   --logger-sasl-reports BOOL   Enables or disables SASL reporting
-echo   --no-halt                    Does not halt the Erlang VM after execution
-echo   --werl                       Uses Erlang's Windows shell GUI (Windows only)
-echo.
-echo Options given after the .exs file or -- are passed down to the executed code.
-echo Options can be passed to the Erlang runtime using $ELIXIR_ERL_OPTIONS or --erl.
-echo.
-echo ## Distribution options
-echo.
-echo The following options are related to node distribution.
-echo.
-echo   --cookie COOKIE              Sets a cookie for this distributed node
-echo   --hidden                     Makes a hidden node
-echo   --name NAME                  Makes and assigns a name to the distributed node
-echo   --rpc-eval NODE "COMMAND"    Evaluates the given command on the given remote node (*)
-echo   --sname NAME                 Makes and assigns a short name to the distributed node
-echo.
-echo ## Release options
-echo.
-echo The following options are generally used under releases.
-echo.
-echo   --boot "FILE"                Uses the given FILE.boot to start the system
-echo   --boot-var VAR "VALUE"       Makes $VAR available as VALUE to FILE.boot (*)
-echo   --erl-config "FILE"          Loads configuration in FILE.config written in Erlang (*)
-echo   --vm-args "FILE"             Passes the contents in file as arguments to the VM
-echo.
-echo --pipe-to is not supported on Windows. If set, Elixir won't boot.
-echo.
-echo ** Options marked with (*) can be given more than once.
+echo ** Options marked with (*) can be given more than once
+echo ** Options given after the .exs file or -- are passed down to the executed code
+echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS or --erl
 goto end
 
 :parseopts
 
-rem Parameters for Elixir
-set parsElixir=
-
 rem Parameters for Erlang
 set parsErlang=
 
+rem Make sure we keep a copy of all parameters
+set allPars=%*
+
+rem Get the original path name from the batch file
+set originPath=%~dp0
+
 rem Optional parameters before the "-extra" parameter
 set beforeExtra=
 
-rem Option which determines whether the loop is over
-set endLoop=0
+rem Flag which determines whether or not to use werl vs erl
+set useWerl=0
 
 rem Designates which mode / Elixir component to run as
 set runMode="elixir"
 
-rem Designates the path to the current script
-set SCRIPT_PATH=%~dp0
-
-rem Designates the path to the ERTS system
-set ERTS_BIN=
-
 rem Recursive loop called for each parameter that parses the cmd line parameters
 :startloop
-set "par=%~1"
-if "!par!"=="" (
-  rem skip if no parameter
+set par="%1"
+shift
+if "%par%"=="" (
+  rem if no parameters defined
   goto expand_erl_libs
 )
-shift
-set par="!par:"=\"!"
-if !endLoop! == 1 (
-  set parsElixir=!parsElixir! !par!
-  goto startloop
+if "%par%"=="""" (
+  rem if no parameters defined - special case for parameter that is already quoted
+  goto expand_erl_libs
 )
 rem ******* EXECUTION OPTIONS **********************
-if !par!=="--werl"   (set useWerl=1 && goto startloop)
-if !par!=="+iex"     (set parsElixir=!parsElixir! +iex && set runMode="iex" && goto startloop)
-if !par!=="+elixirc" (set parsElixir=!parsElixir! +elixirc && set runMode="elixirc" && goto startloop)
-rem ******* EVAL PARAMETERS ************************
-if ""==!par:-e=! (
-  set "VAR=%~1"
-  set parsElixir=!parsElixir! -e "!VAR:"=\"!"
-  shift
-  goto startloop
-)
-if ""==!par:--eval=! (
-  set "VAR=%~1"
-  set parsElixir=!parsElixir! --eval "!VAR:"=\"!"
-  shift
-  goto startloop
-)
-if ""==!par:--rpc-eval=! (
-  set "VAR=%~2"
-  set parsElixir=!parsElixir! --rpc-eval %1 "!VAR:"=\"!"
-  shift
-  shift
-  goto startloop
-)
+if "%par%"==""--werl"" (set useWerl=1)
+if "%par%"==""+iex"" (set runMode="iex")
 rem ******* ELIXIR PARAMETERS **********************
-if ""==!par:-r=!          (set "parsElixir=!parsElixir! -r %1" && shift && goto startloop)
-if ""==!par:-pr=!         (set "parsElixir=!parsElixir! -pr %1" && shift && goto startloop)
-if ""==!par:-pa=!         (set "parsElixir=!parsElixir! -pa %1" && shift && goto startloop)
-if ""==!par:-pz=!         (set "parsElixir=!parsElixir! -pz %1" && shift && goto startloop)
-if ""==!par:-v=!          (set "parsElixir=!parsElixir! -v" && goto startloop)
-if ""==!par:--app=!       (set "parsElixir=!parsElixir! --app %1" && shift && goto startloop)
-if ""==!par:--no-halt=!   (set "parsElixir=!parsElixir! --no-halt" && goto startloop)
-if ""==!par:--remsh=!     (set "parsElixir=!parsElixir! --remsh %1" && shift && goto startloop)
-if ""==!par:--dot-iex=!   (set "parsElixir=!parsElixir! --dot-iex %1" && shift && goto startloop)
+rem Note: we don't have to do anything with options that don't take an argument
+if """"=="%par:-e=%"      (shift)
+if """"=="%par:-r=%"      (shift)
+if """"=="%par:-pr=%"     (shift)
+if """"=="%par:-pa=%"     (shift)
+if """"=="%par:-pz=%"     (shift)
+if """"=="%par:--app=%"   (shift)
+if """"=="%par:--remsh=%" (shift)
 rem ******* ERLANG PARAMETERS **********************
-if ""==!par:--boot=!                (set "parsErlang=!parsErlang! -boot %1" && shift && goto startloop)
-if ""==!par:--boot-var=!            (set "parsErlang=!parsErlang! -boot_var %1 %2" && shift && shift && goto startloop)
-if ""==!par:--cookie=!              (set "parsErlang=!parsErlang! -setcookie %1" && shift && goto startloop)
-if ""==!par:--hidden=!              (set "parsErlang=!parsErlang! -hidden" && goto startloop)
-if ""==!par:--detached=!            (set "parsErlang=!parsErlang! -detached" && echo warning: the --detached option is deprecated && goto startloop)
-if ""==!par:--erl-config=!          (set "parsErlang=!parsErlang! -config %1" && shift && goto startloop)
-if ""==!par:--logger-otp-reports=!  (set "parsErlang=!parsErlang! -logger handle_otp_reports %1" && shift && goto startloop)
-if ""==!par:--logger-sasl-reports=! (set "parsErlang=!parsErlang! -logger handle_sasl_reports %1" && shift && goto startloop)
-if ""==!par:--name=!                (set "parsErlang=!parsErlang! -name %1" && shift && goto startloop)
-if ""==!par:--sname=!               (set "parsErlang=!parsErlang! -sname %1" && shift && goto startloop)
-if ""==!par:--vm-args=!             (set "parsErlang=!parsErlang! -args_file %1" && shift && goto startloop)
-if ""==!par:--erl=!                 (set "beforeExtra=!beforeExtra! %~1" && shift && goto startloop)
-if ""==!par:--pipe-to=!             (echo --pipe-to : Option is not supported on Windows && goto end)
-set endLoop=1
-set parsElixir=!parsElixir! !par!
-goto startloop
+if """"=="%par:--detached=%"            (set parsErlang=%parsErlang% -detached)
+if """"=="%par:--hidden=%"              (set parsErlang=%parsErlang% -hidden)
+if """"=="%par:--cookie=%"              (set parsErlang=%parsErlang% -setcookie %1 && shift)
+if """"=="%par:--sname=%"               (set parsErlang=%parsErlang% -sname %1 && shift)
+if """"=="%par:--name=%"                (set parsErlang=%parsErlang% -name %1 && shift)
+if """"=="%par:--logger-otp-reports=%"  (set parsErlang=%parsErlang% -logger handle_otp_reports %1 && shift)
+if """"=="%par:--logger-sasl-reports=%" (set parsErlang=%parsErlang% -logger handle_sasl_reports %1 && shift)
+if """"=="%par:--erl=%"                 (set beforeExtra=%beforeExtra% %~1 && shift)
+goto:startloop
 
+rem ******* assume all pre-params are parsed ********************
 :expand_erl_libs
-rem expand all ebin paths as Windows does not support the ..\*\ebin wildcard
+rem ******* expand all ebin paths as Windows does not support the ..\*\ebin wildcard ********************
+setlocal enabledelayedexpansion
 set ext_libs=
-for  /d %%d in ("!SCRIPT_PATH!..\lib\*.") do (
+for  /d %%d in ("%originPath%..\lib\*.") do (
   set ext_libs=!ext_libs! -pa "%%~fd\ebin"
 )
+setlocal disabledelayedexpansion
 
 :run
-if not !runMode! == "iex" (
-  set beforeExtra=-noshell -s elixir start_cli !beforeExtra!
+if not %runMode% == "iex" (
+  set beforeExtra=-noshell -s elixir start_cli %beforeExtra%
 )
-if defined useWerl (
-  start "" "!ERTS_BIN!werl.exe" !ext_libs! !ELIXIR_ERL_OPTIONS! !parsErlang! !beforeExtra! -extra !parsElixir!
+if %useWerl% equ 1 (
+  start werl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 ) else (
-  "!ERTS_BIN!erl.exe" !ext_libs! !ELIXIR_ERL_OPTIONS! !parsErlang! !beforeExtra! -extra !parsElixir!
+  erl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 )
 :end
-endlocal
+endlocal

bin/elixirc

@@ -1,24 +1,17 @@
 #!/bin/sh
-set -e
-
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  cat <<USAGE >&2
-Usage: $(basename "$0") [elixir switches] [compiler switches] [.ex files]
+  echo "Usage: `basename $0` [elixir switches] [compiler switches] [.ex files]
 
-  -h, --help                Prints this message and exits
-  -o                        The directory to output compiled files
-  -v, --version             Prints Elixir version and exits
+  -o                   The directory to output compiled files
+  --no-docs            Do not attach documentation to compiled modules
+  --no-debug-info      Do not attach debug info to compiled modules
+  --verbose            Print compilation status
+  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  --ignore-module-conflict
 
-  --ignore-module-conflict  Does not emit warnings if a module was previously defined
-  --no-debug-info           Does not attach debug info to compiled modules
-  --no-docs                 Does not attach documentation to compiled modules
-  --verbose                 Prints compilation status
-  --warnings-as-errors      Treats warnings as errors and return non-zero exit code
-
-Options given after -- are passed down to the executed code.
-Options can be passed to the Erlang runtime using \$ELIXIR_ERL_OPTIONS.
-Options can be passed to the Erlang compiler using \$ERL_COMPILER_OPTIONS.
-USAGE
+** Options given after -- are passed down to the executed code
+** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS
+** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS" >&2
   exit 1
 fi
 
@@ -28,7 +21,7 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 

bin/elixirc.bat

@@ -14,15 +14,12 @@ goto run
 :documentation
 echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
 echo.
-echo   -o                        The directory to output compiled files
-echo.
-echo   --help, -h                Prints this message and exits
-echo   --ignore-module-conflict  Does not emit warnings if a module was previously defined
-echo   --no-debug-info           Does not attach debug info to compiled modules
-echo   --no-docs                 Does not attach documentation to compiled modules
-echo   --verbose                 Prints compilation status
-echo   --version, -v             Prints Elixir version and exits
-echo   --warnings-as-errors      Treats warnings as errors and returns non-zero exit code
+echo  -o                   The directory to output compiled files
+echo  --no-docs            Do not attach documentation to compiled modules
+echo  --no-debug-info      Do not attach debug info to compiled modules
+echo  --verbose            Print compilation status
+echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  --ignore-module-conflict
 echo.
 echo ** Options given after -- are passed down to the executed code
 echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS

bin/iex

@@ -1,18 +1,34 @@
 #!/bin/sh
-set -e
+if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
+  echo "Usage: `basename $0` [options] [.exs file] [data]
 
-if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  cat <<USAGE >&2
-Usage: $(basename "$0") [options] [.exs file] [data]
+  -v                          Prints version and exits
+  -e COMMAND                  Evaluates the given command (*)
+  -r FILE                     Requires the given files/patterns (*)
+  -S SCRIPT                   Finds and executes the given script in PATH
+  -pr FILE                    Requires the given files/patterns in parallel (*)
+  -pa PATH                    Prepends the given path to Erlang code path (*)
+  -pz PATH                    Appends the given path to Erlang code path (*)
 
-The following options are exclusive to IEx:
+  --app APP                   Starts the given app and its dependencies (*)
+  --cookie COOKIE             Sets a cookie for this distributed node
+  --detached                  Starts the Erlang VM detached from console
+  --erl SWITCHES              Switches to be passed down to Erlang (*)
+  --hidden                    Makes a hidden node
+  --logger-otp-reports BOOL   Enables or disables OTP reporting
+  --logger-sasl-reports BOOL  Enables or disables SASL reporting
+  --name NAME                 Makes and assigns a name to the distributed node
+  --no-halt                   Does not halt the Erlang VM after execution
+  --sname NAME                Makes and assigns a short name to the distributed node
+  --werl                      Uses Erlang's Windows shell GUI (Windows only)
 
-  --dot-iex "PATH"    Overrides default .iex.exs file and uses path instead;
-                      path can be empty, then no file will be loaded
-  --remsh NAME        Connects to a node using a remote shell
+  --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
+                              path can be empty, then no file will be loaded
+  --remsh NAME                Connects to a node using a remote shell
 
-It accepts all other options listed by "elixir --help".
-USAGE
+** Options marked with (*) can be given more than once
+** Options given after the .exs file or -- are passed down to the executed code
+** Options can be passed to the VM using ELIXIR_ERL_OPTIONS or --erl" >&2
   exit 1
 fi
 
@@ -22,10 +38,10 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 
 SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
-exec "$SCRIPT_PATH"/elixir --no-halt --erl "-noshell -user Elixir.IEx.CLI" +iex "$@"
+exec "$SCRIPT_PATH"/elixir --no-halt --erl "-user Elixir.IEx.CLI" +iex "$@"

bin/iex.bat

@@ -1,4 +1,4 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
+@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
 setlocal
 if /I ""%1""==""--help"" goto documentation
 if /I ""%1""==""-h""     goto documentation
@@ -9,19 +9,37 @@ goto run
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo The following options are exclusive to IEx:
+echo  -v                          Prints version and exits
+echo  -e COMMAND                  Evaluates the given command (*)
+echo  -r FILE                     Requires the given files/patterns (*)
+echo  -S SCRIPT                   Finds and executes the given script in PATH
+echo  -pr FILE                    Requires the given files/patterns in parallel (*)
+echo  -pa PATH                    Prepends the given path to Erlang code path (*)
+echo  -pz PATH                    Appends the given path to Erlang code path (*)
 echo.
-echo   --dot-iex "PATH"    Overrides default .iex.exs file and uses path instead;
-echo                       path can be empty, then no file will be loaded
-echo   --remsh NAME        Connects to a node using a remote shell
-echo   --werl              Uses Erlang's Windows shell GUI (Windows only)
+echo  --app APP                   Starts the given app and its dependencies (*)
+echo  --cookie COOKIE             Sets a cookie for this distributed node
+echo  --detached                  Starts the Erlang VM detached from console
+echo  --erl SWITCHES              Switches to be passed down to Erlang (*)
+echo  --hidden                    Makes a hidden node
+echo  --logger-otp-reports BOOL   Enables or disables OTP reporting
+echo  --logger-sasl-reports BOOL  Enables or disables SASL reporting
+echo  --name NAME                 Makes and assigns a name to the distributed node
+echo  --no-halt                   Does not halt the Erlang VM after execution
+echo  --sname NAME                Makes and assigns a short name to the distributed node
+echo  --werl                      Uses Erlang's Windows shell GUI (Windows only)
 echo.
-echo Set the IEX_WITH_WERL environment variable to always use werl.
-echo It accepts all other options listed by "elixir --help".
+echo  --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
+echo                              path can be empty, then no file will be loaded
+echo  --remsh NAME                Connects to a node using a remote shell
+echo.
+echo ** Options marked with (*) can be given more than once
+echo ** Options given after the .exs file or -- are passed down to the executed code
+echo ** Options can be passed to the Erlang VM using ELIXIR_ERL_OPTIONS or --erl
 goto end
 
 :run
-if defined IEX_WITH_WERL (@set __ELIXIR_IEX_FLAGS=--werl) else (set __ELIXIR_IEX_FLAGS=)
-call "%~dp0\elixir.bat" --no-halt --erl "-noshell -user Elixir.IEx.CLI" +iex %__ELIXIR_IEX_FLAGS% %*
+@if defined IEX_WITH_WERL (@set __ELIXIR_IEX_FLAGS=--werl) else (set __ELIXIR_IEX_FLAGS=)
+call "%~dp0\elixir.bat" +iex --erl "-user Elixir.IEx.CLI" --no-halt %__ELIXIR_IEX_FLAGS% %*
 :end
 endlocal

bin/mix

@@ -1,3 +1,3 @@
 #!/usr/bin/env elixir
-Mix.start()
-Mix.CLI.main()
+Mix.start
+Mix.CLI.main

lib/eex/lib/eex.ex

@@ -1,7 +1,6 @@
 defmodule EEx.SyntaxError do
   defexception [:message, :file, :line]
 
-  @impl true
   def message(exception) do
     "#{exception.file}:#{exception.line}: #{exception.message}"
   end
@@ -12,7 +11,7 @@ defmodule EEx do
   EEx stands for Embedded Elixir. It allows you to embed
   Elixir code inside a string in a robust way.
 
-      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
       "foo baz"
 
   ## API
@@ -43,8 +42,7 @@ defmodule EEx do
     * `:file` - the file to be used in the template. Defaults to the given
       file the template is read from or to "nofile" when compiling from a string.
     * `:engine` - the EEx engine to be used for compilation.
-    * `:trim` - trims whitespace left/right of quotation tags. If a quotation
-      tag appears on its own in a given line, line endings are also removed.
+    * `:trim` - trims whitespace left/right of quotation tags
 
   ## Engine
 
@@ -76,12 +74,6 @@ defmodule EEx do
         This will never appear
       <% end %>
 
-  To escape an EEx expression in EEx use `<%% content %>`. For example:
-
-      <%%= x + 3 %>
-
-  will be rendered as `<%= x + 3 %>`.
-
   Notice that different engines may have different rules
   for each tag. Other tags may be added in future versions.
 
@@ -91,7 +83,7 @@ defmodule EEx do
   An example is the `@` macro which allows easy data access
   in a template:
 
-      iex> EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
+      iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
       "1"
 
   In other words, `<%= @foo %>` translates to:
@@ -112,7 +104,7 @@ defmodule EEx do
 
       iex> defmodule Sample do
       ...>   require EEx
-      ...>   EEx.function_from_string(:def, :sample, "<%= a + b %>", [:a, :b])
+      ...>   EEx.function_from_string :def, :sample, "<%= a + b %>", [:a, :b]
       ...> end
       iex> Sample.sample(1, 2)
       "3"
@@ -120,13 +112,13 @@ defmodule EEx do
   """
   defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
     quote bind_quoted: binding() do
-      info = Keyword.merge([file: __ENV__.file, line: __ENV__.line], options)
-      args = Enum.map(args, fn arg -> {arg, [line: info[:line]], nil} end)
+      info = Keyword.merge [file: __ENV__.file, line: __ENV__.line], options
+      args = Enum.map args, fn arg -> {arg, [line: info[:line]], nil} end
       compiled = EEx.compile_string(source, info)
 
       case kind do
-        :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)
-        :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)
+        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
+        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
       end
     end
   end
@@ -148,25 +140,24 @@ defmodule EEx do
       # sample.ex
       defmodule Sample do
         require EEx
-        EEx.function_from_file(:def, :sample, "sample.eex", [:a, :b])
+        EEx.function_from_file :def, :sample, "sample.eex", [:a, :b]
       end
 
       # iex
-      Sample.sample(1, 2)
-      #=> "3"
+      Sample.sample(1, 2) #=> "3"
 
   """
   defmacro function_from_file(kind, name, file, args \\ [], options \\ []) do
     quote bind_quoted: binding() do
-      info = Keyword.merge(options, file: file, line: 1)
-      args = Enum.map(args, fn arg -> {arg, [line: 1], nil} end)
+      info = Keyword.merge options, [file: file, line: 1]
+      args = Enum.map args, fn arg -> {arg, [line: 1], nil} end
       compiled = EEx.compile_file(file, info)
 
       @external_resource file
       @file file
       case kind do
-        :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)
-        :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)
+        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
+        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
       end
     end
   end
@@ -175,7 +166,7 @@ defmodule EEx do
   Gets a string `source` and generate a quoted expression
   that can be evaluated by Elixir or compiled to a function.
   """
-  @spec compile_string(String.t(), keyword) :: Macro.t()
+  @spec compile_string(String.t, Keyword.t) :: Macro.t | no_return
   def compile_string(source, options \\ []) when is_binary(source) and is_list(options) do
     EEx.Compiler.compile(source, options)
   end
@@ -184,9 +175,9 @@ defmodule EEx do
   Gets a `filename` and generate a quoted expression
   that can be evaluated by Elixir or compiled to a function.
   """
-  @spec compile_file(String.t(), keyword) :: Macro.t()
+  @spec compile_file(String.t, Keyword.t) :: Macro.t | no_return
   def compile_file(filename, options \\ []) when is_binary(filename) and is_list(options) do
-    options = Keyword.merge(options, file: filename, line: 1)
+    options = Keyword.merge options, [file: filename, line: 1]
     compile_string(File.read!(filename), options)
   end
 
@@ -195,11 +186,11 @@ defmodule EEx do
 
   ## Examples
 
-      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
       "foo baz"
 
   """
-  @spec eval_string(String.t(), keyword, keyword) :: any
+  @spec eval_string(String.t, Keyword.t, Keyword.t) :: any
   def eval_string(source, bindings \\ [], options \\ [])
       when is_binary(source) and is_list(bindings) and is_list(options) do
     compiled = compile_string(source, options)
@@ -215,14 +206,13 @@ defmodule EEx do
       foo <%= bar %>
 
       # iex
-      EEx.eval_file("sample.eex", bar: "baz")
-      #=> "foo baz"
+      EEx.eval_file "sample.eex", [bar: "baz"] #=> "foo baz"
 
   """
-  @spec eval_file(String.t(), keyword, keyword) :: any
+  @spec eval_file(String.t, Keyword.t, Keyword.t) :: any
   def eval_file(filename, bindings \\ [], options \\ [])
       when is_binary(filename) and is_list(bindings) and is_list(options) do
-    options = Keyword.put(options, :file, filename)
+    options  = Keyword.put options, :file, filename
     compiled = compile_file(filename, options)
     do_eval(compiled, bindings, options)
   end

lib/eex/lib/eex/compiler.ex

@@ -9,25 +9,16 @@ defmodule EEx.Compiler do
   and the engine together by handling the tokens and invoking
   the engine every time a full expression or text is received.
   """
-  @spec compile(String.t(), keyword) :: Macro.t()
+  @spec compile(String.t, Keyword.t) :: Macro.t | no_return
   def compile(source, opts) when is_binary(source) and is_list(opts) do
-    file = opts[:file] || "nofile"
-    line = opts[:line] || 1
-    trim = opts[:trim] || false
-
+    file   = opts[:file] || "nofile"
+    line   = opts[:line] || 1
+    trim   = opts[:trim] || false
     case EEx.Tokenizer.tokenize(source, line, trim: trim) do
       {:ok, tokens} ->
-        state = %{
-          engine: opts[:engine] || @default_engine,
-          file: file,
-          line: line,
-          quoted: [],
-          start_line: nil
-        }
-
-        init = state.engine.init(opts)
-        generate_buffer(tokens, init, [], state)
-
+        state = %{engine: opts[:engine] || @default_engine,
+                  file: file, line: line, quoted: [], start_line: nil}
+        generate_buffer(tokens, state.engine.init(opts), [], state)
       {:error, line, message} ->
         raise EEx.SyntaxError, line: line, file: file, message: message
     end
@@ -36,94 +27,39 @@ defmodule EEx.Compiler do
   # Generates the buffers by handling each expression from the tokenizer.
   # It returns Macro.t/0 or it raises.
 
-  defp generate_buffer([{:text, chars} | rest], buffer, scope, state) do
+  defp generate_buffer([{:text, chars} | t], buffer, scope, state) do
     buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
-    generate_buffer(rest, buffer, scope, state)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:expr, line, mark, chars, _} | rest], buffer, scope, state) do
-    expr = Code.string_to_quoted!(chars, line: line, file: state.file)
+  defp generate_buffer([{:expr, line, mark, chars} | t], buffer, scope, state) do
+    expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
     buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)
-    generate_buffer(rest, buffer, scope, state)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:start_expr, start_line, mark, chars, _} | rest], buffer, scope, state) do
-    {contents, line, rest} = look_ahead_middle(rest, start_line, chars)
-
-    {contents, rest} =
-      generate_buffer(
-        rest,
-        state.engine.handle_begin(buffer),
-        [contents | scope],
-        %{state | quoted: [], line: line, start_line: start_line}
-      )
-
+  defp generate_buffer([{:start_expr, start_line, mark, chars} | t], buffer, scope, state) do
+    {contents, line, t} = look_ahead_text(t, start_line, chars)
+    {contents, t} = generate_buffer(t, "", [contents | scope],
+                                    %{state | quoted: [], line: line, start_line: start_line})
     buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), contents)
-    generate_buffer(rest, buffer, scope, state)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer(
-         [{:middle_expr, line, '', chars, _} | rest],
-         buffer,
-         [current | scope],
-         state
-       ) do
+  defp generate_buffer([{:middle_expr, line, _, chars} | t], buffer, [current | scope], state) do
     {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    state = %{state | line: line}
-    generate_buffer(rest, state.engine.handle_begin(buffer), [wrapped | scope], state)
+    generate_buffer(t, "", [wrapped | scope], %{state | line: line})
   end
 
-  defp generate_buffer(
-         [{:middle_expr, line, modifier, chars, trimmed?} | t],
-         buffer,
-         [_ | _] = scope,
-         state
-       ) do
-    message =
-      "unexpected beginning of EEx tag \"<%#{modifier}\" on \"<%#{modifier}#{chars}%>\", " <>
-        "please remove \"#{modifier}\" accordingly"
-
-    :elixir_errors.erl_warn(line, state.file, message)
-    generate_buffer([{:middle_expr, line, '', chars, trimmed?} | t], buffer, scope, state)
-    # TODO: Make this an error on Elixir v2.0 since it accidentally worked previously.
-    # raise EEx.SyntaxError, message: message, file: state.file, line: line
-  end
-
-  defp generate_buffer([{:middle_expr, line, _, chars, _} | _], _buffer, [], state) do
-    raise EEx.SyntaxError,
-      message: "unexpected middle of expression <%#{chars}%>",
-      file: state.file,
-      line: line
-  end
-
-  defp generate_buffer([{:end_expr, line, '', chars, _} | rest], buffer, [current | _], state) do
+  defp generate_buffer([{:end_expr, line, _, chars} | t], buffer, [current | _], state) do
     {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    tuples = Code.string_to_quoted!(wrapped, line: state.start_line, file: state.file)
+    tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
     buffer = insert_quoted(tuples, state.quoted)
-    {buffer, rest}
+    {buffer, t}
   end
 
-  defp generate_buffer(
-         [{:end_expr, line, modifier, chars, trimmed?} | t],
-         buffer,
-         [_ | _] = scope,
-         state
-       ) do
-    message =
-      "unexpected beginning of EEx tag \"<%#{modifier}\" on end of " <>
-        "expression \"<%#{modifier}#{chars}%>\", please remove \"#{modifier}\" accordingly"
-
-    :elixir_errors.erl_warn(line, state.file, message)
-    generate_buffer([{:end_expr, line, '', chars, trimmed?} | t], buffer, scope, state)
-    # TODO: Make this an error on Elixir v2.0 since it accidentally worked previously.
-    # raise EEx.SyntaxError, message: message, file: state.file, line: line
-  end
-
-  defp generate_buffer([{:end_expr, line, _, chars, _} | _], _buffer, [], state) do
-    raise EEx.SyntaxError,
-      message: "unexpected end of expression <%#{chars}%>",
-      file: state.file,
-      line: line
+  defp generate_buffer([{:end_expr, line, _, chars} | _], _buffer, [], state) do
+    raise EEx.SyntaxError, message: "unexpected token #{inspect chars}", file: state.file, line: line
   end
 
   defp generate_buffer([], buffer, [], state) do
@@ -131,10 +67,8 @@ defmodule EEx.Compiler do
   end
 
   defp generate_buffer([], _buffer, _scope, state) do
-    raise EEx.SyntaxError,
-      message: "unexpected end of string, expected a closing '<% end %>'",
-      file: state.file,
-      line: state.line
+    raise EEx.SyntaxError, message: "unexpected end of string, expected a closing '<% end %>'",
+                           file: state.file, line: state.line
   end
 
   # Creates a placeholder and wrap it inside the expression block
@@ -143,32 +77,24 @@ defmodule EEx.Compiler do
     new_lines = List.duplicate(?\n, line - state.line)
     key = length(state.quoted)
     placeholder = '__EEX__(' ++ Integer.to_charlist(key) ++ ');'
-    count = current ++ placeholder ++ new_lines ++ chars
-    new_state = %{state | quoted: [{key, state.engine.handle_end(buffer)} | state.quoted]}
-
-    {count, new_state}
+    {current ++ placeholder ++ new_lines ++ chars,
+     %{state | quoted: [{key, buffer} | state.quoted]}}
   end
 
-  # Look middle expressions that immediately follow a start_expr
+  # Look text ahead on expressions
 
-  defp look_ahead_middle(
-         [{:text, text}, {:middle_expr, line, _, chars, _} | rest] = tokens,
-         start,
-         contents
-       ) do
+  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars} | t]=list, start, contents) do
     if only_spaces?(text) do
-      {contents ++ text ++ chars, line, rest}
+      {contents ++ text ++ chars, line, t}
     else
-      {contents, start, tokens}
+      {contents, start, list}
     end
   end
-
-  defp look_ahead_middle([{:middle_expr, line, _, chars, _} | rest], _start, contents) do
-    {contents ++ chars, line, rest}
+  defp look_ahead_text([{:middle_expr, line, _, chars} | t], _start, contents) do
+    {contents ++ chars, line, t}
   end
-
-  defp look_ahead_middle(tokens, start, contents) do
-    {contents, start, tokens}
+  defp look_ahead_text(t, start, contents) do
+    {contents, start, t}
   end
 
   defp only_spaces?(chars) do
@@ -178,7 +104,7 @@ defmodule EEx.Compiler do
   # Changes placeholder to real expression
 
   defp insert_quoted({:__EEX__, _, [key]}, quoted) do
-    {^key, value} = List.keyfind(quoted, key, 0)
+    {^key, value} = List.keyfind quoted, key, 0
     value
   end
 
@@ -191,7 +117,7 @@ defmodule EEx.Compiler do
   end
 
   defp insert_quoted(list, quoted) when is_list(list) do
-    Enum.map(list, &insert_quoted(&1, quoted))
+    Enum.map list, &insert_quoted(&1, quoted)
   end
 
   defp insert_quoted(other, _quoted) do

lib/eex/lib/eex/engine.ex

@@ -2,71 +2,35 @@ defmodule EEx.Engine do
   @moduledoc ~S"""
   Basic EEx engine that ships with Elixir.
 
-  An engine needs to implement all callbacks below.
+  An engine needs to implement four functions:
 
-  An engine may also `use EEx.Engine` to get the default behaviour
-  but this is not advised. In such cases, if any of the callbacks
-  are overridden, they must call `super()` to delegate to the
-  underlying `EEx.Engine`.
+    * `init(opts)` - returns the initial buffer
+
+    * `handle_body(quoted)` - receives the final built quoted
+      expression, should do final post-processing and return a
+      quoted expression.
+
+    * `handle_text(buffer, text)` - it receives the buffer,
+      the text and must return a new quoted expression.
+
+    * `handle_expr(buffer, marker, expr)` - it receives the buffer,
+      the marker, the expr and must return a new quoted expression.
+
+      The marker is what follows exactly after `<%`. For example,
+      `<% foo %>` has an empty marker, but `<%= foo %>` has `"="`
+      as marker. The allowed markers so far are: `""` and `"="`.
+
+      Read `handle_expr/3` below for more information about the markers
+      implemented by default by this engine.
+
+  `EEx.Engine` can be used directly if one desires to use the
+  default implementations for the functions above.
   """
 
-  @type state :: term
-
-  @doc """
-  Called at the beginning of every template.
-
-  It must return the initial state.
-  """
-  @callback init(opts :: keyword) :: state
-
-  @doc """
-  Called at the end of every template.
-
-  It must return Elixir's quoted expressions for the template.
-  """
-  @callback handle_body(state) :: Macro.t()
-
-  @doc """
-  Called for the text/static parts of a template.
-
-  It must return the updated state.
-  """
-  @callback handle_text(state, text :: String.t()) :: state
-
-  @doc """
-  Called for the dynamic/code parts of a template.
-
-  The marker is what follows exactly after `<%`. For example,
-  `<% foo %>` has an empty marker, but `<%= foo %>` has `"="`
-  as marker. The allowed markers so far are:
-
-    * `""`
-    * `"="`
-    * `"/"`
-    * `"|"`
-
-  Markers `"/"` and `"|"` are only for use in custom EEx engines
-  and are not implemented by default. Using them without an
-  appropriate implementation raises `EEx.SyntaxError`.
-
-  It must return the updated state.
-  """
-  @callback handle_expr(state, marker :: String.t(), expr :: Macro.t()) :: state
-
-  @doc """
-  Invoked at the beginning of every nesting.
-
-  It must return a new state that is used only inside the nesting.
-  Once the nesting terminates, the current `state` is resumed.
-  """
-  @callback handle_begin(state) :: state
-
-  @doc """
-  Invokes at the end of a nesting.
-
-  It must return Elixir's quoted expressions for the nesting.
-  """
-  @callback handle_end(state) :: Macro.t()
+  @callback init(opts :: Keyword.t) :: Macro.t
+  @callback handle_body(quoted :: Macro.t) :: Macro.t
+  @callback handle_text(buffer :: Macro.t, text :: String.t) :: Macro.t
+  @callback handle_expr(buffer :: Macro.t, marker :: String.t, expr :: Macro.t) :: Macro.t
 
   @doc false
   defmacro __using__(_) do
@@ -77,27 +41,19 @@ defmodule EEx.Engine do
         EEx.Engine.init(opts)
       end
 
-      def handle_body(state) do
-        EEx.Engine.handle_body(state)
+      def handle_body(quoted) do
+        EEx.Engine.handle_body(quoted)
       end
 
-      def handle_begin(state) do
-        EEx.Engine.handle_begin(state)
+      def handle_text(buffer, text) do
+        EEx.Engine.handle_text(buffer, text)
       end
 
-      def handle_end(state) do
-        EEx.Engine.handle_end(state)
+      def handle_expr(buffer, marker, expr) do
+        EEx.Engine.handle_expr(buffer, marker, expr)
       end
 
-      def handle_text(state, text) do
-        EEx.Engine.handle_text(state, text)
-      end
-
-      def handle_expr(state, marker, expr) do
-        EEx.Engine.handle_expr(state, marker, expr)
-      end
-
-      defoverridable EEx.Engine
+      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2, init: 1]
     end
   end
 
@@ -110,110 +66,78 @@ defmodule EEx.Engine do
   This can be added to any custom engine by invoking
   `handle_assign/1` with `Macro.prewalk/2`:
 
-      def handle_expr(state, token, expr) do
+      def handle_expr(buffer, token, expr) do
         expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
-        super(state, token, expr)
+        EEx.Engine.handle_expr(buffer, token, expr)
       end
 
   """
-  @spec handle_assign(Macro.t()) :: Macro.t()
+  @spec handle_assign(Macro.t) :: Macro.t
   def handle_assign({:@, meta, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
     line = meta[:line] || 0
-    quote(line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name)))
+    quote line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name))
   end
-
   def handle_assign(arg) do
     arg
   end
 
   @doc false
-  # TODO: Raise on v2.0
-  @spec fetch_assign!(Access.t(), Access.key()) :: term | nil
+  # TODO: Raise on 2.0
+  @spec fetch_assign!(map, Map.key) :: term | nil
   def fetch_assign!(assigns, key) do
     case Access.fetch(assigns, key) do
       {:ok, val} ->
         val
-
       :error ->
         keys = Enum.map(assigns, &elem(&1, 0))
-
-        IO.warn(
-          "assign @#{key} not available in EEx template. " <>
-            "Please ensure all assigns are given as options. " <>
-            "Available assigns: #{inspect(keys)}"
-        )
-
+        IO.warn "assign @#{key} not available in EEx template. " <>
+                "Please ensure all assigns are given as options. " <>
+                "Available assigns: #{inspect keys}"
         nil
     end
   end
 
-  @doc false
+  @doc """
+  Returns an empty string as initial buffer.
+  """
   def init(_opts) do
-    %{
-      binary: [],
-      dynamic: [],
-      vars_count: 0
-    }
+    ""
   end
 
-  @doc false
-  def handle_begin(state) do
-    check_state!(state)
-    %{state | binary: [], dynamic: []}
+  @doc """
+  The default implementation simply returns the given expression.
+  """
+  def handle_body(quoted) do
+    quoted
   end
 
-  @doc false
-  def handle_end(quoted) do
-    handle_body(quoted)
+  @doc """
+  The default implementation simply concatenates text to the buffer.
+  """
+  def handle_text(buffer, text) do
+    quote do: unquote(buffer) <> unquote(text)
   end
 
-  @doc false
-  def handle_body(state) do
-    check_state!(state)
-    %{binary: binary, dynamic: dynamic} = state
-    binary = {:<<>>, [], Enum.reverse(binary)}
-    dynamic = [binary | dynamic]
-    {:__block__, [], Enum.reverse(dynamic)}
+  @doc """
+  Implements expressions according to the markers.
+
+      <% Elixir expression - inline with output %>
+      <%= Elixir expression - replace with result %>
+
+  All other markers are not implemented by this engine.
+  """
+  def handle_expr(buffer, "=", expr) do
+    quote do
+      tmp1 = unquote(buffer)
+      tmp1 <> String.Chars.to_string(unquote(expr))
+    end
   end
 
-  @doc false
-  def handle_text(state, text) do
-    %{binary: binary} = state
-    %{state | binary: [text | binary]}
-  end
-
-  @doc false
-  def handle_expr(state, "=", ast) do
-    %{binary: binary, dynamic: dynamic, vars_count: vars_count} = state
-    var = Macro.var(:"arg#{vars_count}", __MODULE__)
-
-    ast =
-      quote do
-        unquote(var) = String.Chars.to_string(unquote(ast))
-      end
-
-    segment =
-      quote do
-        unquote(var) :: binary
-      end
-
-    %{state | dynamic: [ast | dynamic], binary: [segment | binary], vars_count: vars_count + 1}
-  end
-
-  def handle_expr(state, "", ast) do
-    %{dynamic: dynamic} = state
-    %{state | dynamic: [ast | dynamic]}
-  end
-
-  def handle_expr(_state, marker, _ast) when marker in ["/", "|"] do
-    raise EEx.SyntaxError,
-          "unsupported EEx syntax <%#{marker} %> (the syntax is valid but not supported by the current EEx engine)"
-  end
-
-  defp check_state!(%{binary: _, dynamic: _, vars_count: _}), do: :ok
-
-  defp check_state!(state) do
-    raise "unexpected EEx.Engine state: #{inspect(state)}. " <>
-            "This typically means a bug or an outdated EEx.Engine or tool"
+  def handle_expr(buffer, "", expr) do
+    quote do
+      tmp2 = unquote(buffer)
+      unquote(expr)
+      tmp2
+    end
   end
 end

lib/eex/lib/eex/smart_engine.ex

@@ -24,12 +24,11 @@ defmodule EEx.SmartEngine do
       # sample.ex
       defmodule Sample do
         require EEx
-        EEx.function_from_file(:def, :sample, "sample.eex", [:assigns])
+        EEx.function_from_file :def, :sample, "sample.eex", [:assigns]
       end
 
       # iex
-      Sample.sample(a: 1, b: 2)
-      #=> "3"
+      Sample.sample(a: 1, b: 2) #=> "3"
 
   """
 

lib/eex/lib/eex/tokenizer.ex

@@ -1,16 +1,10 @@
 defmodule EEx.Tokenizer do
   @moduledoc false
 
-  @type content :: IO.chardata()
+  @type content :: IO.chardata
   @type line :: non_neg_integer
-  @type marker :: '=' | '/' | '|' | ''
-  @type trimmed? :: boolean
-  @type token ::
-          {:text, content}
-          | {:expr | :start_expr | :middle_expr | :end_expr, line, marker, content, trimmed?}
-
-  @spaces [?\s, ?\t]
-  @closing_brackets ')]}'
+  @type token :: {:text, content} |
+                 {:expr | :start_expr | :middle_expr | :end_expr, line, '=' | '', content}
 
   @doc """
   Tokenizes the given charlist or binary.
@@ -18,14 +12,14 @@ defmodule EEx.Tokenizer do
   It returns {:ok, list} with the following tokens:
 
     * `{:text, content}`
-    * `{:expr, line, marker, content, trimmed?}`
-    * `{:start_expr, line, marker, content, trimmed?}`
-    * `{:middle_expr, line, marker, content, trimmed?}`
-    * `{:end_expr, line, marker, content, trimmed?}`
+    * `{:expr, line, marker, content}`
+    * `{:start_expr, line, marker, content}`
+    * `{:middle_expr, line, marker, content}`
+    * `{:end_expr, line, marker, content}`
 
   Or `{:error, line, error}` in case of errors.
   """
-  @spec tokenize(binary | charlist, line, keyword) :: {:ok, [token]} | {:error, line, String.t()}
+  @spec tokenize(binary | charlist, line, Keyword.t) :: {:ok, [token]} | {:error, line, String.t}
   def tokenize(bin, line, opts \\ [])
 
   def tokenize(bin, line, opts)
@@ -39,17 +33,15 @@ defmodule EEx.Tokenizer do
   end
 
   defp tokenize('<%%' ++ t, line, opts, buffer, acc) do
-    tokenize(t, line, opts, [?%, ?< | buffer], acc)
+   tokenize t, line, opts, [?%, ?< | buffer], acc
   end
 
   defp tokenize('<%#' ++ t, line, opts, buffer, acc) do
     case expr(t, line, []) do
-      {:error, _, _} = error ->
-        error
-
+      {:error, _, _} = error -> error
       {:ok, _, new_line, rest} ->
-        {_, rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        tokenize(rest, new_line, opts, buffer, acc)
+        {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
+        tokenize rest, new_line, opts, buffer, acc
     end
   end
 
@@ -57,25 +49,22 @@ defmodule EEx.Tokenizer do
     {marker, t} = retrieve_marker(t)
 
     case expr(t, line, []) do
-      {:error, _, _} = error ->
-        error
-
+      {:error, _, _} = error -> error
       {:ok, expr, new_line, rest} ->
         token = token_name(expr)
-        {trimmed?, rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        expr = pad_if_needed(token, expr, trimmed?)
-        acc = tokenize_text(buffer, acc)
-        final = {token, line, marker, Enum.reverse(expr), trimmed?}
-        tokenize(rest, new_line, opts, [], [final | acc])
+        {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
+        acc   = tokenize_text(buffer, acc)
+        final = {token, line, marker, Enum.reverse(expr)}
+        tokenize rest, new_line, opts, [], [final | acc]
     end
   end
 
   defp tokenize('\n' ++ t, line, opts, buffer, acc) do
-    tokenize(t, line + 1, opts, [?\n | buffer], acc)
+    tokenize t, line + 1, opts, [?\n | buffer], acc
   end
 
   defp tokenize([h | t], line, opts, buffer, acc) do
-    tokenize(t, line, opts, [h | buffer], acc)
+    tokenize t, line, opts, [h | buffer], acc
   end
 
   defp tokenize([], _line, _opts, buffer, acc) do
@@ -84,8 +73,8 @@ defmodule EEx.Tokenizer do
 
   # Retrieve marker for <%
 
-  defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do
-    {[marker], t}
+  defp retrieve_marker('=' ++ t) do
+    {'=', t}
   end
 
   defp retrieve_marker(t) do
@@ -99,11 +88,11 @@ defmodule EEx.Tokenizer do
   end
 
   defp expr('\n' ++ t, line, buffer) do
-    expr(t, line + 1, [?\n | buffer])
+    expr t, line + 1, [?\n | buffer]
   end
 
   defp expr([h | t], line, buffer) do
-    expr(t, line, [h | buffer])
+    expr t, line, [h | buffer]
   end
 
   defp expr([], line, _buffer) do
@@ -115,30 +104,27 @@ defmodule EEx.Tokenizer do
   #
   # Start tokens finish with "do" and "fn ->"
   # Middle tokens are marked with "->" or keywords
-  # End tokens contain only the end word and optionally
-  # combinations of ")", "]" and "}".
+  # End tokens contain only the end word and optionally ")"
 
-  defp token_name([h | t]) when h in @spaces do
+  defp token_name([h | t]) when h in [?\s, ?\t, ?)] do
     token_name(t)
   end
 
-  defp token_name('od' ++ [h | rest]) when h in @spaces or h in @closing_brackets do
-    case tokenize_rest(rest) do
-      {:ok, [{:end, _} | _]} -> :middle_expr
-      _ -> :start_expr
-    end
+  defp token_name('od' ++ [h | _]) when h in [?\s, ?\t, ?)] do
+    :start_expr
   end
 
   defp token_name('>-' ++ rest) do
-    case tokenize_rest(rest) do
-      {:ok, [{:end, _} | _]} ->
-        :middle_expr
+    rest = Enum.reverse(rest)
 
-      # Check if there is a "fn" token and, if so, it is not
-      # followed by an "end" token. If this is the case, we
-      # are on a start expr.
-      {:ok, tokens} ->
-        tokens = Enum.reverse(tokens)
+    # Tokenize the remaining passing check_terminators as
+    # false, which relax the tokenizer to not error on
+    # unmatched pairs. Then, we check if there is a "fn"
+    # token and, if so, it is not followed by an "end"
+    # token. If this is the case, we are on a start expr.
+    case :elixir_tokenizer.tokenize(rest, 1, file: "eex", check_terminators: false) do
+      {:ok, _line, _column, tokens} ->
+        tokens   = Enum.reverse(tokens)
         fn_index = fn_index(tokens)
 
         if fn_index && end_index(tokens) > fn_index do
@@ -146,37 +132,27 @@ defmodule EEx.Tokenizer do
         else
           :middle_expr
         end
-
       _error ->
         :middle_expr
     end
   end
 
-  defp token_name('esle' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('retfa' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('hctac' ++ t), do: check_spaces(t, :middle_expr)
+  defp token_name('esle' ++ t),   do: check_spaces(t, :middle_expr)
+  defp token_name('retfa' ++ t),  do: check_spaces(t, :middle_expr)
+  defp token_name('hctac' ++ t),  do: check_spaces(t, :middle_expr)
   defp token_name('eucser' ++ t), do: check_spaces(t, :middle_expr)
+  defp token_name('dne' ++ t),    do: check_spaces(t, :end_expr)
 
-  defp token_name(rest) do
-    case Enum.drop_while(rest, &(&1 in @spaces or &1 in @closing_brackets)) do
-      'dne' ++ t -> check_spaces(t, :end_expr)
-      _ -> :expr
-    end
-  end
-
-  # Tokenize the remaining passing check_terminators as false,
-  # which relax the tokenizer to not error on unmatched pairs.
-  # If the tokens start with an "end" we have a middle expr.
-  defp tokenize_rest(rest) do
-    :elixir_tokenizer.tokenize(Enum.reverse(rest), 1, file: "eex", check_terminators: false)
+  defp token_name(_) do
+    :expr
   end
 
   defp fn_index(tokens) do
-    Enum.find_index(tokens, fn
+    Enum.find_index tokens, fn
       {:fn_paren, _} -> true
-      {:fn, _} -> true
-      _ -> false
-    end)
+      {:fn, _}       -> true
+      _              -> false
+    end
   end
 
   defp end_index(tokens) do
@@ -184,7 +160,7 @@ defmodule EEx.Tokenizer do
   end
 
   defp check_spaces(string, token) do
-    if Enum.all?(string, &(&1 in @spaces)) do
+    if Enum.all?(string, &(&1 in [?\s, ?\t])) do
       token
     else
       :expr
@@ -206,19 +182,22 @@ defmodule EEx.Tokenizer do
   # only itself and whitespace, trim the whitespace around it,
   # including the line break following it if there is one.
   defp trim_if_needed(rest, line, opts, buffer, acc) do
-    with true <- opts[:trim],
-         {true, new_buffer} <- trim_left(buffer, acc),
-         {true, new_rest, new_line} <- trim_right(rest, line) do
-      {true, new_rest, new_line, new_buffer}
+    original = {rest, line, buffer}
+    if opts[:trim] do
+      case {trim_left(buffer, acc), trim_right(rest, line)} do
+        {{true, new_buffer}, {true, new_rest, new_line}} ->
+          {new_rest, new_line, new_buffer}
+        _ ->
+          original
+      end
     else
-      _ -> {false, rest, line, buffer}
+      original
     end
   end
 
   defp trim_left(buffer, acc) do
     case {trim_whitespace(buffer), acc} do
       {[?\n | _] = trimmed_buffer, _} -> {true, trimmed_buffer}
-      {[], [{_, _, _, _, true} | _]} -> {true, []}
       {[], []} -> {true, []}
       _ -> {false, buffer}
     end
@@ -233,14 +212,11 @@ defmodule EEx.Tokenizer do
     end
   end
 
-  defp trim_whitespace([h | t]) when h in @spaces do
+  defp trim_whitespace([h | t]) when h == ?\s or h == ?\t do
     trim_whitespace(t)
   end
 
   defp trim_whitespace(list) do
     list
   end
-
-  defp pad_if_needed(:start_expr, [h | _] = expr, true) when h not in @spaces, do: [?\s | expr]
-  defp pad_if_needed(_, expr, _), do: expr
 end

lib/eex/mix.exs

@@ -1,11 +1,9 @@
-defmodule EEx.MixProject do
+defmodule EEx.Mixfile do
   use Mix.Project
 
   def project do
-    [
-      app: :eex,
-      version: System.version(),
-      build_per_environment: false
-    ]
+    [app: :eex,
+     version: System.version,
+     build_per_environment: false]
   end
 end

lib/eex/test/eex/smart_engine_test.exs

@@ -1,50 +1,45 @@
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.SmartEngineTest do
   use ExUnit.Case, async: true
 
+  import ExUnit.CaptureIO
+
   test "evaluates simple string" do
-    assert_eval("foo bar", "foo bar")
+    assert_eval "foo bar", "foo bar"
   end
 
   test "evaluates with assigns as keywords" do
-    assert_eval("1", "<%= @foo %>", assigns: [foo: 1])
+    assert_eval "1", "<%= @foo %>", assigns: [foo: 1]
   end
 
   test "evaluates with assigns as a map" do
-    assert_eval("1", "<%= @foo %>", assigns: %{foo: 1})
+    assert_eval "1", "<%= @foo %>", assigns: %{foo: 1}
   end
 
   test "error with missing assigns" do
-    stderr =
-      ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        assert_eval("", "<%= @foo %>", assigns: %{})
-      end)
-
+    stderr = capture_io(:stderr, fn ->
+      assert_eval "", "<%= @foo %>", assigns: %{}
+    end)
     assert stderr =~ "assign @foo not available in EEx template"
   end
 
   test "evaluates with loops" do
-    assert_eval("1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>")
+    assert_eval "1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>"
   end
 
-  test "preserves line numbers in assignments" do
-    result = EEx.compile_string("foo\n<%= @hello %>", engine: EEx.SmartEngine)
-
+  test "compiled preserved line numbers" do
+    result = EEx.compile_string("<%= @hello %>", engine: EEx.SmartEngine)
     Macro.prewalk(result, fn
-      {_left, meta, [_, :hello]} ->
-        assert Keyword.get(meta, :line) == 2
-        send(self(), :found)
-
-      node ->
-        node
+      {_left, meta, _right} ->
+        assert Keyword.get(meta, :line, 0) in [0, 1]
+      _ ->
+        :ok
     end)
-
-    assert_received :found
   end
 
   defp assert_eval(expected, actual, binding \\ []) do
-    result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.SmartEngine)
+    result = EEx.eval_string(actual, binding, file: __ENV__.file)
     assert result == expected
   end
 end

lib/eex/test/eex/tokenizer_test.exs

@@ -1,4 +1,4 @@
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.TokenizerTest do
   use ExUnit.Case, async: true
@@ -14,196 +14,137 @@ defmodule EEx.TokenizerTest do
 
   test "strings with embedded code" do
     assert T.tokenize('foo <% bar %>', 1) ==
-             {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar ', false}]}
+           {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar '}]}
   end
 
   test "strings with embedded equals code" do
     assert T.tokenize('foo <%= bar %>', 1) ==
-             {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar ', false}]}
-  end
-
-  test "strings with embedded slash code" do
-    assert T.tokenize('foo <%/ bar %>', 1) ==
-             {:ok, [{:text, 'foo '}, {:expr, 1, '/', ' bar ', false}]}
-  end
-
-  test "strings with embedded pipe code" do
-    assert T.tokenize('foo <%| bar %>', 1) ==
-             {:ok, [{:text, 'foo '}, {:expr, 1, '|', ' bar ', false}]}
+           {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar '}]}
   end
 
   test "strings with more than one line" do
     assert T.tokenize('foo\n<%= bar %>', 1) ==
-             {:ok, [{:text, 'foo\n'}, {:expr, 2, '=', ' bar ', false}]}
+           {:ok, [{:text, 'foo\n'}, {:expr, 2, '=', ' bar '}]}
   end
 
   test "strings with more than one line and expression with more than one line" do
     string = '''
-    foo <%= bar
+foo <%= bar
 
-    baz %>
-    <% foo %>
-    '''
+baz %>
+<% foo %>
+'''
 
-    exprs = [
+    assert T.tokenize(string, 1) == {:ok, [
       {:text, 'foo '},
-      {:expr, 1, '=', ' bar\n\nbaz ', false},
+      {:expr, 1, '=', ' bar\n\nbaz '},
       {:text, '\n'},
-      {:expr, 4, '', ' foo ', false},
+      {:expr, 4, '', ' foo '},
       {:text, '\n'}
-    ]
-
-    assert T.tokenize(string, 1) == {:ok, exprs}
+    ]}
   end
 
   test "quotation" do
-    assert T.tokenize('foo <%% true %>', 1) == {:ok, [{:text, 'foo <% true %>'}]}
+    assert T.tokenize('foo <%% true %>', 1) == {:ok, [
+      {:text, 'foo <% true %>'}
+    ]}
   end
 
   test "quotation with do/end" do
-    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) ==
-             {:ok, [{:text, 'foo <% true do %>bar<% end %>'}]}
+    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == {:ok, [
+      {:text, 'foo <% true do %>bar<% end %>'}
+    ]}
   end
 
   test "quotation with interpolation" do
-    exprs = [
+    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, [
       {:text, 'a <% b '},
-      {:expr, 1, '=', ' c ', false},
+      {:expr, 1, '=', ' c '},
       {:text, ' '},
-      {:expr, 1, '=', ' d ', false},
+      {:expr, 1, '=', ' d '},
       {:text, ' e %> f'}
-    ]
+    ]}
 
-    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, exprs}
-  end
-
-  test "improperly formatted quotation with interpolation" do
-    exprs = [
+    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, [
       {:text, '<%% a <%= b %> c %>'}
-    ]
-
-    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "comments" do
-    exprs = [
+    assert T.tokenize('foo <%# true %>', 1) == {:ok, [
       {:text, 'foo '}
-    ]
-
-    assert T.tokenize('foo <%# true %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "comments with do/end" do
-    exprs = [
+    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == {:ok, [
       {:text, 'foo bar'}
-    ]
-
-    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "strings with embedded do end" do
-    exprs = [
+    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, [
       {:text, 'foo '},
-      {:start_expr, 1, '', ' if true do ', false},
+      {:start_expr, 1, '', ' if true do '},
       {:text, 'bar'},
-      {:end_expr, 1, '', ' end ', false}
-    ]
-
-    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, exprs}
+      {:end_expr, 1, '', ' end '}
+    ]}
   end
 
   test "strings with embedded -> end" do
-    exprs = [
+    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == {:ok, [
       {:text, 'foo '},
-      {:start_expr, 1, '', ' cond do ', false},
-      {:middle_expr, 1, '', ' false -> ', false},
+      {:start_expr, 1, '', ' cond do '},
+      {:middle_expr, 1, '', ' false -> '},
       {:text, 'bar'},
-      {:middle_expr, 1, '', ' true -> ', false},
+      {:middle_expr, 1, '', ' true -> '},
       {:text, 'baz'},
-      {:end_expr, 1, '', ' end ', false}
-    ]
-
-    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) ==
-             {:ok, exprs}
-  end
-
-  test "strings with multiple callbacks" do
-    exprs = [
-      {:start_expr, 1, '=', ' a fn -> ', false},
-      {:text, 'foo'},
-      {:middle_expr, 1, '', ' end, fn -> ', false},
-      {:text, 'bar'},
-      {:end_expr, 1, '', ' end ', false}
-    ]
-
-    assert T.tokenize('<%= a fn -> %>foo<% end, fn -> %>bar<% end %>', 1) == {:ok, exprs}
-  end
-
-  test "strings with callback followed by do block" do
-    exprs = [
-      {:start_expr, 1, '=', ' a fn -> ', false},
-      {:text, 'foo'},
-      {:middle_expr, 1, '', ' end do ', false},
-      {:text, 'bar'},
-      {:end_expr, 1, '', ' end ', false}
-    ]
-
-    assert T.tokenize('<%= a fn -> %>foo<% end do %>bar<% end %>', 1) == {:ok, exprs}
+      {:end_expr, 1, '', ' end '}
+    ]}
   end
 
   test "strings with embedded keywords blocks" do
-    exprs = [
+    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, [
       {:text, 'foo '},
-      {:start_expr, 1, '', ' if true do ', false},
+      {:start_expr, 1, '', ' if true do '},
       {:text, 'bar'},
-      {:middle_expr, 1, '', ' else ', false},
+      {:middle_expr, 1, '', ' else '},
       {:text, 'baz'},
-      {:end_expr, 1, '', ' end ', false}
-    ]
-
-    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, exprs}
+      {:end_expr, 1, '', ' end '}
+    ]}
   end
 
   test "trim mode" do
     template = '\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  '
-
-    exprs = [
-      {:start_expr, 1, '=', ' if true do ', true},
+    assert T.tokenize(template, 1, trim: true) == {:ok, [
+      {:start_expr, 1, '=', ' if true do '},
       {:text, ' TRUE \n'},
-      {:middle_expr, 3, '', ' else ', true},
+      {:middle_expr, 3, '', ' else '},
       {:text, ' FALSE \n'},
-      {:end_expr, 5, '', ' end ', true}
-    ]
-
-    assert T.tokenize(template, 1, trim: true) == {:ok, exprs}
+      {:end_expr, 5, '', ' end '}
+    ]}
   end
 
   test "trim mode with comment" do
-    exprs = [
+    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, [
       {:text, '123'}
-    ]
-
-    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode with CRLF" do
-    exprs = [
+    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, [
       {:text, '0\r\n'},
-      {:expr, 2, '=', ' 12 ', true},
+      {:expr, 2, '=', ' 12 '},
       {:text, '34'}
-    ]
-
-    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode set to false" do
-    exprs = [
+    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, [
       {:text, ' '},
-      {:expr, 1, '=', ' 12 ', false},
+      {:expr, 1, '=', ' 12 '},
       {:text, ' \n'}
-    ]
-
-    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode no false positives" do

lib/eex/test/eex_test.exs

@@ -1,36 +1,39 @@
-Code.require_file("test_helper.exs", __DIR__)
+Code.require_file "test_helper.exs", __DIR__
 
 require EEx
 
 defmodule EExTest.Compiled do
   def before_compile do
-    {__ENV__.line, hd(tl(get_stacktrace()))}
+    fill_in_stacktrace()
+    {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
-  EEx.function_from_string(:def, :string_sample, "<%= a + b %>", [:a, :b])
+  EEx.function_from_string :def, :string_sample, "<%= a + b %>", [:a, :b]
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-  EEx.function_from_file(:defp, :private_file_sample, filename, [:bar])
+  EEx.function_from_file :defp, :private_file_sample, filename, [:bar]
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-  EEx.function_from_file(:def, :public_file_sample, filename, [:bar])
+  EEx.function_from_file :def, :public_file_sample, filename, [:bar]
 
   def file_sample(arg), do: private_file_sample(arg)
 
   def after_compile do
-    {__ENV__.line, hd(tl(get_stacktrace()))}
+    fill_in_stacktrace()
+    {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
   @file "unknown"
   def unknown do
-    {__ENV__.line, hd(tl(get_stacktrace()))}
+    fill_in_stacktrace()
+    {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
-  defp get_stacktrace do
+  defp fill_in_stacktrace do
     try do
-      :erlang.error("failed")
-    rescue
-      _ -> __STACKTRACE__
+      :erlang.error "failed"
+    catch
+      :error, _ -> System.stacktrace
     end
   end
 end
@@ -50,565 +53,372 @@ defmodule EExTest do
   doctest EEx.Engine
   doctest EEx.SmartEngine
 
-  describe "evaluates" do
-    test "simple string" do
-      assert_eval("foo bar", "foo bar")
-    end
+  test "evaluates simple string" do
+    assert_eval "foo bar", "foo bar"
+  end
 
-    test "Unicode" do
-      template = """
-        • <%= "•" %> •
-        <%= "Jößé Vâlìm" %> Jößé Vâlìm
-      """
+  test "evaluates with embedded" do
+    assert_eval "foo bar", "foo <%= :bar %>"
+  end
 
-      assert_eval("  • • •\n  Jößé Vâlìm Jößé Vâlìm\n", template)
-    end
+  test "evaluates with embedded and the binding" do
+    assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
+  end
 
-    test "no spaces" do
-      string = """
-      <%=cond do%>
-      <%false ->%>
-        this
-      <%true ->%>
-        that
-      <%end%>
-      """
+  test "evaluates with embedded do end" do
+    assert_eval "foo bar", "foo <%= if true do %>bar<% end %>"
+  end
 
-      expected = "\n  that\n\n"
-      assert_eval(expected, string, [])
-    end
+  test "evaluates with embedded do end and eval the expression" do
+    assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
+  end
 
-    test "trim mode" do
-      string = "<%= 123 %> \n456\n  <%= 789 %>"
-      expected = "123456\n789"
-      assert_eval(expected, string, [], trim: true)
-    end
+  test "evaluates with embedded do end and nested print expression" do
+    assert_eval "foo bar", "foo <%= if true do %><%= :bar %><% end %>"
+  end
 
-    test "trim mode with middle expression" do
-      string = """
-      <%= cond do %>
-      <% false -> %>
-        this
-      <% true -> %>
-        that
-      <% end %>
-      """
+  test "evaluates with embedded do end and nested expressions" do
+    assert_eval "foo bar baz", "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
+    assert Process.get(:eex_text) == 1
+  end
 
-      expected = "  that\n"
-      assert_eval(expected, string, [], trim: true)
-    end
+  test "evaluates with embedded middle expression" do
+    assert_eval "foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>"
+  end
 
-    test "trim mode with multiple lines" do
-      string = """
-      <%= "First line" %>
-      <%= "Second line" %>
-      <%= "Third line" %>
-      <%= "Fourth line" %>
-      """
+  test "evaluates with embedded middle expression and eval the expression" do
+    assert_eval "foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>"
+  end
 
-      expected = "First lineSecond lineThird lineFourth line"
-      assert_eval(expected, string, [], trim: true)
-    end
+  test "evaluates with nested start expression" do
+    assert_eval "foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>"
+  end
 
-    test "trim mode with no spaces" do
-      string = """
-      <%=cond do%>
-      <%false ->%>
-        this
-      <%true ->%>
-        that
-      <%end%>
-      """
+  test "evaluates with nested middle expression" do
+    assert_eval "foo baz", "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
+  end
 
-      expected = "  that\n"
-      assert_eval(expected, string, [], trim: true)
-    end
+  test "evaluates with parentheses after end in end token" do
+    assert_eval " 101  102  103 ", "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
+  end
 
-    test "embedded code" do
-      assert_eval("foo bar", "foo <%= :bar %>")
-    end
+  test "evaluates with defined variable" do
+    assert_eval "foo 1", "foo <% bar = 1 %><%= bar %>"
+  end
 
-    test "embedded code with binding" do
-      assert EEx.eval_string("foo <%= bar %>", bar: 1) == "foo 1"
-    end
+  test "evaluates with require code" do
+    assert_eval "foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>"
+  end
 
-    test "embedded code with do end when true" do
-      assert_eval("foo bar", "foo <%= if true do %>bar<% end %>")
-    end
+  test "evaluates with end of token" do
+    assert_eval "foo bar %>", "foo bar %>"
+  end
 
-    test "embedded code with do end when false" do
-      assert_eval("foo ", "foo <%= if false do %>bar<% end %>")
-    end
-
-    test "embedded code with do preceded by bracket" do
-      assert_eval("foo bar", "foo <%= if {true}do %>bar<% end %>")
-      assert_eval("foo bar", "foo <%= if (true)do %>bar<% end %>")
-      assert_eval("foo bar", "foo <%= if [true]do %>bar<% end %>")
-    end
-
-    test "embedded code with do end and expression" do
-      assert_eval("foo bar", "foo <%= if true do %><%= :bar %><% end %>")
-    end
-
-    test "embedded code with do end and multiple expressions" do
-      assert_eval(
-        "foo bar baz",
-        "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
-      )
-
-      assert Process.get(:eex_text) == 1
-    end
-
-    test "embedded code with middle expression" do
-      assert_eval("foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>")
-    end
-
-    test "embedded code with evaluated middle expression" do
-      assert_eval("foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>")
-    end
-
-    test "embedded code with nested do end" do
-      assert_eval("foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>")
-    end
-
-    test "embedded code with nested do end with middle expression" do
-      assert_eval(
-        "foo baz",
-        "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
-      )
-    end
-
-    test "embedded code with end followed by bracket" do
-      assert_eval(
-        " 101  102  103 ",
-        "<%= Enum.map([1, 2, 3], fn x -> %> <%= 100 + x %> <% end) %>"
-      )
-
-      assert_eval(
-        " 101  102  103 ",
-        "<%= apply Enum, :map, [[1, 2, 3], fn x -> %> <%= 100 + x %> <% end] %>"
-      )
-
-      assert_eval(
-        " 101  102  103 ",
-        "<%= #{__MODULE__}.tuple_map {[1, 2, 3], fn x -> %> <%= 100 + x %> <% end} %>"
-      )
-
-      assert_eval(
-        " 101  102  103 ",
-        "<%= apply(Enum, :map, [[1, 2, 3], fn x -> %> <%= 100 + x %> <% end]) %>"
-      )
-
-      assert_eval(
-        " 101  102  103 ",
-        "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
-      )
-    end
-
-    test "embedded code with variable definition" do
-      assert_eval("foo 1", "foo <% bar = 1 %><%= bar %>")
-    end
-
-    test "embedded code with require" do
-      assert_eval("foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>")
-    end
-
-    test "with end of token" do
-      assert_eval("foo bar %>", "foo bar %>")
+  test "raises a syntax error when the token is invalid" do
+    assert_raise EEx.SyntaxError, "nofile:1: missing token '%>'", fn ->
+      EEx.compile_string "foo <%= bar"
     end
   end
 
-  describe "raises syntax errors" do
-    test "when the token is invalid" do
-      assert_raise EEx.SyntaxError, "nofile:1: missing token '%>'", fn ->
-        EEx.compile_string("foo <%= bar")
-      end
-    end
-
-    test "when middle expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1: unexpected middle of expression <% else %>", fn ->
-        EEx.compile_string("<% if true %> foo<% else %>bar<% end %>")
-      end
-    end
-
-    test "when end expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1: unexpected end of expression <% end %>", fn ->
-        EEx.compile_string("foo <% end %>")
-      end
-    end
-
-    test "when start expression is found without an end expression" do
-      msg = "nofile:2: unexpected end of string, expected a closing '<% end %>'"
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("foo\n<% if true do %>")
-      end
-    end
-
-    test "when nested end expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1: unexpected end of expression <% end %>", fn ->
-        EEx.compile_string("foo <% if true do %><% end %><% end %>")
-      end
-    end
-
-    test "when middle expression has a modifier" do
-      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
-               EEx.compile_string("foo <%= if true do %>true<%= else %>false<% end %>")
-             end) =~ ~s[unexpected beginning of EEx tag \"<%=\" on \"<%= else %>\"]
-    end
-
-    test "when end expression has a modifier" do
-      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
-               EEx.compile_string("foo <%= if true do %>true<% else %>false<%= end %>")
-             end) =~
-               ~s[unexpected beginning of EEx tag \"<%=\" on end of expression \"<%= end %>\"]
-    end
-
-    test "when trying to use marker '/' without implementation" do
-      msg =
-        ~r/unsupported EEx syntax <%\/ %> \(the syntax is valid but not supported by the current EEx engine\)/
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("<%/ true %>")
-      end
-    end
-
-    test "when trying to use marker '|' without implementation" do
-      msg =
-        ~r/unsupported EEx syntax <%| %> \(the syntax is valid but not supported by the current EEx engine\)/
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("<%| true %>")
-      end
+  test "raises a syntax error when end expression is found without a start expression" do
+    assert_raise EEx.SyntaxError, "nofile:1: unexpected token ' end '",  fn ->
+      EEx.compile_string "foo <% end %>"
     end
   end
 
-  describe "error messages" do
-    test "honor line numbers" do
-      assert_raise EEx.SyntaxError, "nofile:99: missing token '%>'", fn ->
-        EEx.compile_string("foo <%= bar", line: 99)
-      end
-    end
-
-    test "honor file names" do
-      assert_raise EEx.SyntaxError, "my_file.eex:1: missing token '%>'", fn ->
-        EEx.compile_string("foo <%= bar", file: "my_file.eex")
-      end
+  test "raises a syntax error when start expression is found without an end expression" do
+    assert_raise EEx.SyntaxError, "nofile:2: unexpected end of string, expected a closing '<% end %>'", fn ->
+      EEx.compile_string "foo\n<% if true do %>"
     end
   end
 
-  describe "environment" do
-    test "respects line numbers" do
-      expected = """
-      foo
-      2
-      """
-
-      string = """
-      foo
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line numbers inside nested expressions" do
-      expected = """
-      foo
-
-      3
-
-      5
-      """
-
-      string = """
-      foo
-      <%= if true do %>
-      <%= __ENV__.line %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line numbers inside start expression" do
-      expected = """
-      foo
-
-      true
-
-      5
-      """
-
-      string = """
-      foo
-      <%= if __ENV__.line == 2 do %>
-      <%= true %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line numbers inside middle expression with ->" do
-      expected = """
-      foo
-
-      true
-
-      7
-      """
-
-      string = """
-      foo
-      <%= cond do %>
-      <% false -> %> false
-      <% __ENV__.line == 4 -> %>
-      <%= true %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line number inside middle expressions with keywords" do
-      expected = """
-      foo
-
-      5
-
-      7
-      """
-
-      string = """
-      foo
-      <%= if false do %>
-      <%= __ENV__.line %>
-      <% else %>
-      <%= __ENV__.line %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects files" do
-      assert_eval("sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex")
+  test "raises a syntax error when nested end expression is found without a start expression" do
+    assert_raise EEx.SyntaxError, "nofile:1: unexpected token ' end '", fn ->
+      EEx.compile_string "foo <% if true do %><% end %><% end %>"
     end
   end
 
-  describe "clauses" do
-    test "inside functions" do
-      expected = """
+  test "respects line numbers" do
+    expected = """
+foo
+2
+"""
 
-      Number 1
+    string = """
+foo
+<%= __ENV__.line %>
+"""
 
-      Number 2
+    assert_eval expected, string
+  end
 
-      Number 3
+  test "respects line numbers inside nested expressions" do
+    expected = """
+foo
 
-      """
+3
 
-      string = """
-      <%= Enum.map [1, 2, 3], fn x -> %>
-      Number <%= x %>
-      <% end %>
-      """
+5
+"""
 
-      assert_eval(expected, string)
-    end
+    string = """
+foo
+<%= if true do %>
+<%= __ENV__.line %>
+<% end %>
+<%= __ENV__.line %>
+"""
 
-    test "inside multiple functions" do
-      expected = """
+    assert_eval expected, string
+  end
 
-      A 1
+  test "respects line numbers inside start expression" do
+    expected = """
+foo
 
-      B 2
+true
 
-      A 3
+5
+"""
 
-      """
+    string = """
+foo
+<%= if __ENV__.line == 2 do %>
+<%= true %>
+<% end %>
+<%= __ENV__.line %>
+"""
 
-      string = """
-      <%= #{__MODULE__}.switching_map [1, 2, 3], fn x -> %>
-      A <%= x %>
-      <% end, fn x -> %>
-      B <%= x %>
-      <% end %>
-      """
+    assert_eval expected, string
+  end
 
-      assert_eval(expected, string)
-    end
+  test "respects line numbers inside middle expression with ->" do
+    expected = """
+foo
 
-    test "inside callback and do block" do
-      expected = """
+true
 
+7
+"""
 
-      A 1
+    string = """
+foo
+<%= cond do %>
+<% false -> %> false
+<% __ENV__.line == 4 -> %>
+<%= true %>
+<% end %>
+<%= __ENV__.line %>
+"""
 
-      B 2
+    assert_eval expected, string
+  end
 
-      A 3
+  test "respects line number inside middle expressions with keywords" do
+    expected = """
+foo
 
-      """
+5
 
-      string = """
-      <% require #{__MODULE__} %>
-      <%= #{__MODULE__}.switching_macro [1, 2, 3], fn x -> %>
-      A <%= x %>
-      <% end do %>
-      B <%= x %>
-      <% end %>
-      """
+7
+"""
 
-      assert_eval(expected, string)
-    end
+    string = """
+foo
+<%= if false do %>
+<%= __ENV__.line %>
+<% else %>
+<%= __ENV__.line %>
+<% end %>
+<%= __ENV__.line %>
+"""
 
-    test "inside cond" do
-      expected = """
-      foo
+    assert_eval expected, string
+  end
 
-      true
+  test "respects files" do
+    assert_eval "sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex"
+  end
 
-      """
+  test "properly handle functions" do
+    expected = """
 
-      string = """
-      foo
-      <%= cond do %>
-      <% false -> %> false
-      <% fn -> 1 end -> %>
-      <%= true %>
-      <% end %>
-      """
+Number 1
 
-      assert_eval(expected, string)
-    end
+Number 2
 
-    test "inside cond with do end" do
-      string = """
-      <% y = ["a", "b", "c"] %>
-      <%= cond do %>
-       <% "a" in y -> %>
-        Good
-       <% true -> %>
-        <% if true do %>true<% else %>false<% end %>
-        Bad
-      <% end %>
-      """
+Number 3
 
-      assert_eval("\n\n  Good\n \n", string)
+"""
+
+    string = """
+<%= Enum.map [1, 2, 3], fn x -> %>
+Number <%= x %>
+<% end %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "properly handle functions on the left side of clauses" do
+    expected = """
+foo
+
+true
+
+"""
+
+    string = """
+foo
+<%= cond do %>
+<% false -> %> false
+<% fn -> 1 end -> %>
+<%= true %>
+<% end %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "evaluates nested do expressions" do
+    string = """
+    <% y = ["a", "b", "c"] %>
+    <%= cond do %>
+     <% "a" in y -> %>
+      Good
+     <% true -> %>
+      <% if true do %>true<% else %>false<% end %>
+      Bad
+    <% end %>
+    """
+
+    assert_eval "\n\n  Good\n \n", string
+  end
+
+  test "evaluates expressions with buffers" do
+    string = """
+    <%= 123 %>
+    <% if true do %>
+      <%= 456 %>
+    <% end %>
+    <%= 789 %>
+    """
+
+    assert_eval "123\n\n789\n", string
+  end
+
+  test "for comprehensions" do
+    string = """
+    <%= for _name <- packages || [] do %>
+    <% end %>
+    <%= all || :done %>
+    """
+    assert_eval "\ndone\n", string, packages: nil, all: nil
+  end
+
+  test "Unicode" do
+    template = """
+      • <%= "•" %> •
+      <%= "Jößé Vâlìm" %> Jößé Vâlìm
+    """
+    result = EEx.eval_string(template)
+    assert result == "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n"
+  end
+
+  test "trim mode" do
+    string = "<%= 123 %> \n456\n  <%= 789 %>"
+    expected = "123456\n789"
+    assert_eval expected, string, [], trim: true
+  end
+
+  test "trim mode with middle expression" do
+    string = """
+    <%= cond do %>
+    <% false -> %>
+      this
+    <% true -> %>
+      that
+    <% end %>
+    """
+    expected = "  that\n"
+    assert_eval expected, string, [], trim: true
+  end
+
+  test "evaluates the source from a given file" do
+    filename = Path.join(__DIR__, "fixtures/eex_template.eex")
+    result = EEx.eval_file(filename)
+    assert result == "foo bar.\n"
+  end
+
+  test "evaluates the source from a given file with bindings" do
+    filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
+    result = EEx.eval_file(filename, [bar: 1])
+    assert result == "foo 1\n"
+  end
+
+  test "raises an Exception when there's an error with the given file" do
+    assert_raise File.Error, "could not read file \"non-existent.eex\": no such file or directory", fn ->
+      filename = "non-existent.eex"
+      EEx.compile_file(filename)
     end
   end
 
-  describe "buffers" do
-    test "unused buffers are kept out" do
-      string = """
-      <%= 123 %>
-      <% if true do %>
-        <%= 456 %>
-      <% end %>
-      <%= 789 %>
-      """
-
-      assert_eval("123\n\n789\n", string)
-    end
-
-    test "inside comprehensions" do
-      string = """
-      <%= for _name <- packages || [] do %>
-      <% end %>
-      <%= all || :done %>
-      """
-
-      assert_eval("\ndone\n", string, packages: nil, all: nil)
-    end
+  test "sets external resource attribute" do
+    assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
+           [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
   end
 
-  describe "from file" do
-    test "evaluates the source" do
-      filename = Path.join(__DIR__, "fixtures/eex_template.eex")
-      result = EEx.eval_file(filename)
-      assert_normalized_newline_equal("foo bar.\n", result)
-    end
-
-    test "evaluates the source with bindings" do
-      filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-      result = EEx.eval_file(filename, bar: 1)
-      assert_normalized_newline_equal("foo 1\n", result)
-    end
-
-    test "raises an Exception when file is missing" do
-      msg = "could not read file \"non-existent.eex\": no such file or directory"
-
-      assert_raise File.Error, msg, fn ->
-        filename = "non-existent.eex"
-        EEx.compile_file(filename)
-      end
-    end
-
-    test "sets external resource attribute" do
-      assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
-               [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
-    end
+  test "defined from string" do
+    assert EExTest.Compiled.string_sample(1, 2) == "3"
   end
 
-  describe "precompiled" do
-    test "from string" do
-      assert EExTest.Compiled.string_sample(1, 2) == "3"
-    end
+  test "defined from file" do
+    assert EExTest.Compiled.file_sample(1) == "foo 1\n"
+    assert EExTest.Compiled.public_file_sample(1) == "foo 1\n"
+  end
 
-    test "from file" do
-      assert_normalized_newline_equal("foo 1\n", EExTest.Compiled.file_sample(1))
-      assert_normalized_newline_equal("foo 1\n", EExTest.Compiled.public_file_sample(1))
-    end
+  test "defined from file do not affect backtrace" do
+    assert EExTest.Compiled.before_compile ==
+      {8,
+        {EExTest.Compiled,
+          :before_compile,
+          0,
+          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 7]
+       }
+     }
 
-    test "from file does not affect backtrace" do
-      file = to_charlist(Path.relative_to_cwd(__ENV__.file))
+    assert EExTest.Compiled.after_compile ==
+      {23,
+        {EExTest.Compiled,
+          :after_compile,
+          0,
+          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 22]
+       }
+     }
 
-      assert EExTest.Compiled.before_compile() ==
-               {7, {EExTest.Compiled, :before_compile, 0, [file: file, line: 7]}}
-
-      assert EExTest.Compiled.after_compile() ==
-               {21, {EExTest.Compiled, :after_compile, 0, [file: file, line: 21]}}
-
-      assert EExTest.Compiled.unknown() ==
-               {26, {EExTest.Compiled, :unknown, 0, [file: 'unknown', line: 26]}}
-    end
+    assert EExTest.Compiled.unknown ==
+      {29,
+        {EExTest.Compiled,
+          :unknown,
+          0,
+          [file: 'unknown', line: 28]
+       }
+     }
   end
 
   defmodule TestEngine do
     @behaviour EEx.Engine
 
     def init(_opts) do
-      "INIT"
+      ""
     end
 
     def handle_body(body) do
-      "BODY(#{body})"
-    end
-
-    def handle_begin(_) do
-      "BEGIN"
-    end
-
-    def handle_end(buffer) do
-      buffer <> ":END"
+      {:wrapped, body}
     end
 
     def handle_text(buffer, text) do
-      buffer <> ":TEXT(#{String.trim(text)})"
-    end
-
-    def handle_expr(buffer, "/", expr) do
-      buffer <> ":DIV(#{Macro.to_string(expr)})"
-    end
-
-    def handle_expr(buffer, "=", expr) do
-      buffer <> ":EQUAL(#{Macro.to_string(expr)})"
+      EEx.Engine.handle_text(buffer, text)
     end
 
     def handle_expr(buffer, mark, expr) do
@@ -616,64 +426,13 @@ defmodule EExTest do
     end
   end
 
-  describe "custom engines" do
-    test "text" do
-      assert_eval("BODY(INIT:TEXT(foo))", "foo", [], engine: TestEngine)
-    end
-
-    test "custom marker" do
-      assert_eval("BODY(INIT:TEXT(foo):DIV(:bar))", "foo <%/ :bar %>", [], engine: TestEngine)
-    end
-
-    test "begin/end" do
-      assert_eval(
-        ~s[BODY(INIT:TEXT(foo):EQUAL(if do\n  "BEGIN:TEXT(this):END"\nelse\n  "BEGIN:TEXT(that):END"\nend))],
-        "foo <%= if do %>this<% else %>that<% end %>",
-        [],
-        engine: TestEngine
-      )
-    end
-
-    test "not implemented custom marker" do
-      msg =
-        ~r/unsupported EEx syntax <%| %> \(the syntax is valid but not supported by the current EEx engine\)/
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        assert_eval({:wrapped, "foo baz"}, "foo <%| :bar %>", [], engine: TestEngine)
-      end
-    end
+  test "calls handle_body" do
+    assert {:wrapped, "foo"} = EEx.eval_string("foo", [], engine: TestEngine)
   end
 
   defp assert_eval(expected, actual, binding \\ [], opts \\ []) do
-    opts = Keyword.merge([file: __ENV__.file, engine: opts[:engine] || EEx.Engine], opts)
+    opts = Enum.into [file: __ENV__.file, engine: EEx.Engine], opts
     result = EEx.eval_string(actual, binding, opts)
     assert result == expected
   end
-
-  defp assert_normalized_newline_equal(expected, actual) do
-    assert String.replace(expected, "\r\n", "\n") == String.replace(actual, "\r\n", "\n")
-  end
-
-  def tuple_map({list, callback}) do
-    Enum.map(list, callback)
-  end
-
-  def switching_map(list, a, b) do
-    list
-    |> Enum.with_index()
-    |> Enum.map(fn
-      {element, index} when rem(index, 2) == 0 -> a.(element)
-      {element, index} when rem(index, 2) == 1 -> b.(element)
-    end)
-  end
-
-  defmacro switching_macro(list, a, do: block) do
-    quote do
-      b = fn var!(x) ->
-        unquote(block)
-      end
-
-      unquote(__MODULE__).switching_map(unquote(list), unquote(a), b)
-    end
-  end
 end

lib/eex/test/test_helper.exs

@@ -1 +1 @@
-ExUnit.start(trace: "--trace" in System.argv())
+ExUnit.start [trace: "--trace" in System.argv]

lib/elixir/docs.exs

@@ -1,103 +0,0 @@
-# Returns config for Elixir docs
-[
-  extras: Path.wildcard("lib/elixir/pages/*.md"),
-  groups_for_functions: [
-    Guards: & &1[:guard] == true
-  ],
-  skip_undefined_reference_warnings_on: ["compatibility-and-deprecations"],
-  groups_for_modules: [
-    # [Kernel, Kernel.SpecialForms],
-
-    "Basic Types": [
-      Atom,
-      Base,
-      Bitwise,
-      Date,
-      DateTime,
-      Exception,
-      Float,
-      Function,
-      Integer,
-      Module,
-      NaiveDateTime,
-      Record,
-      Regex,
-      String,
-      Time,
-      Tuple,
-      URI,
-      Version,
-      Version.Requirement
-    ],
-    "Collections & Enumerables": [
-      Access,
-      Date.Range,
-      Enum,
-      Keyword,
-      List,
-      Map,
-      MapSet,
-      Range,
-      Stream
-    ],
-    "IO & System": [
-      File,
-      File.Stat,
-      File.Stream,
-      IO,
-      IO.ANSI,
-      IO.Stream,
-      OptionParser,
-      Path,
-      Port,
-      StringIO,
-      System
-    ],
-    "Calendar": [
-      Calendar,
-      Calendar.ISO,
-      Calendar.TimeZoneDatabase,
-      Calendar.UTCOnlyTimeZoneDatabase
-    ],
-    "Processes & Applications": [
-      Agent,
-      Application,
-      Config,
-      Config.Provider,
-      Config.Reader,
-      DynamicSupervisor,
-      GenServer,
-      Node,
-      Process,
-      Registry,
-      Supervisor,
-      Task,
-      Task.Supervisor
-    ],
-    Protocols: [
-      Collectable,
-      Enumerable,
-      Inspect,
-      Inspect.Algebra,
-      Inspect.Opts,
-      List.Chars,
-      Protocol,
-      String.Chars
-    ],
-    "Code & Macros": [
-      Code,
-      Kernel.ParallelCompiler,
-      Macro,
-      Macro.Env
-    ],
-    Deprecated: [
-      Behaviour,
-      Dict,
-      GenEvent,
-      HashDict,
-      HashSet,
-      Set,
-      Supervisor.Spec
-    ]
-  ]
-]

lib/elixir/generate_app.escript

@@ -1,13 +0,0 @@
-#!/usr/bin/env escript
-%% -*- erlang -*-
-
-main([Source, Target, Version]) ->
-  {ok, [{application, Name, Props0}]} = file:consult(Source),
-  Ebin = filename:dirname(Target),
-  Files = filelib:wildcard(filename:join(Ebin, "*.beam")),
-  Mods = [list_to_atom(filename:basename(F, ".beam")) || F <- Files],
-  Props1 = lists:keyreplace(modules, 1, Props0, {modules, Mods}),
-  Props = lists:keyreplace(vsn, 1, Props1, {vsn, Version}),
-  AppDef = io_lib:format("~tp.~n", [{application, Name, Props}]),
-  ok = file:write_file(Target, AppDef),
-  io:format("Generated ~ts app~n", [Name]).

lib/elixir/lib/access.ex

@@ -1,19 +1,27 @@
 defmodule Access do
   @moduledoc """
-  Key-based access to data structures.
+  Key-based access to data structures using the `data[key]` syntax.
 
-  The `Access` module defines a behaviour for dynamically accessing
-  keys of any type in a data structure via the `data[key]` syntax.
+  Elixir provides two syntaxes for accessing values. `user[:name]`
+  is used by dynamic structures, like maps and keywords, while
+  `user.name` is used by structs. The main difference is that
+  `user[:name]` won't raise if the key `:name` is missing but
+  `user.name` will raise if there is no `:name` key.
 
-  `Access` supports keyword lists (`Keyword`) and maps (`Map`) out
-  of the box. The key can be of any type and it returns `nil` if
-  the key does not exist:
+  Besides the cases above, this module provides convenience
+  functions for accessing other structures, like `at/1` for
+  lists and `elem/1` for tuples. Those functions can be used
+  by the nested update functions in `Kernel`, such as
+  `Kernel.get_in/2`, `Kernel.put_in/3`, `Kernel.update_in/3`,
+  `Kernel.get_and_update_in/3` and friends.
+
+  ## Dynamic lookups
+
+  Out of the box, `Access` works with `Keyword` and `Map`:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:a]
       1
-      iex> keywords[:c]
-      nil
 
       iex> map = %{a: 1, b: 2}
       iex> map[:a]
@@ -23,100 +31,120 @@ defmodule Access do
       iex> star_ratings[1.5]
       "★☆"
 
+  Note that the dynamic lookup syntax (`term[key]`) roughly translates to
+  `Access.get(term, key, nil)`.
+
+  `Access` can be combined with `Kernel.put_in/3` to put a value
+  in a given key:
+
+      iex> map = %{a: 1, b: 2}
+      iex> put_in map[:a], 3
+      %{a: 3, b: 2}
+
   This syntax is very convenient as it can be nested arbitrarily:
 
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in users["john"][:age], 28
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+  Furthermore, `Access` transparently ignores `nil` values:
+
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:c][:unknown]
       nil
 
-  This works because accessing anything on a `nil` value, returns
-  `nil` itself:
+  Since `Access` is a behaviour, it can be implemented for key-value
+  data structures. The implementation should be added to the
+  module that defines the struct being accessed. `Access` requires the
+  key comparison to be implemented using the `===` operator.
 
-      iex> nil[:a]
-      nil
+  ## Static lookups
 
-  The access syntax can also be used with the `Kernel.put_in/2`,
-  `Kernel.update_in/2` and `Kernel.get_and_update_in/2` macros
-  to allow values to be set in nested data structures:
+  The `Access` syntax (`foo[bar]`) cannot be used to access fields in
+  structs, since structs do not implement the `Access` behaviour by
+  default. It is also a design decision: the dynamic access lookup
+  is meant to be used for dynamic key-value structures, like maps
+  and keywords, and not by static ones like structs (where fields are
+  known and not dynamic).
 
-      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
-      iex> put_in(users["john"][:age], 28)
-      %{"john" => %{age: 28}, "meg" => %{age: 23}}
+  Therefore Elixir provides a static lookup for struct fields and for atom
+  fields in maps. Imagine a struct named `User` with a `:name` field.
+  The following would raise:
 
-  > Attention! While the access syntax is allowed in maps via
-  > `map[key]`, if your map is made of predefined atom keys,
-  > you should prefer to access those atom keys with `map.key`
-  > instead of `map[key]`, as `map.key` will raise if the key
-  > is missing. This is important because, if a map has a predefined
-  > set of keys and a key is missing, it is most likely a bug
-  > in your software or a typo on the key name. For this reason,
-  > because structs are predefined in nature, they only allow
-  > the `struct.key` syntax and they do not allow the `struct[key]`
-  > access syntax. See the `Map` module for more information.
+      user = %User{name: "John"}
+      user[:name]
+      # ** (UndefinedFunctionError) undefined function User.fetch/2
+      #    (User does not implement the Access behaviour)
 
-  ## Nested data structures
+  Structs instead use the `user.name` syntax to access fields:
 
-  Both key-based access syntaxes can be used with the nested update
-  functions and macros in `Kernel`, such as `Kernel.get_in/2`,
-  `Kernel.put_in/3`, `Kernel.update_in/3`, `Kernel.pop_in/2`, and
-  `Kernel.get_and_update_in/3`.
+      user.name
+      #=> "John"
 
-  For example, to update a map inside another map:
+  The same `user.name` syntax can also be used by `Kernel.put_in/2`
+  to for updating structs fields:
 
-      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
-      iex> put_in(users["john"].age, 28)
-      %{"john" => %{age: 28}, "meg" => %{age: 23}}
+      put_in user.name, "Mary"
+      #=> %User{name: "Mary"}
 
-  This module provides convenience functions for traversing other
-  structures, like tuples and lists. These functions can be used
-  in all the `Access`-related functions and macros in `Kernel`.
+  Differently from `user[:name]`, `user.name` is not extensible via
+  a behaviour and is restricted only to structs and atom keys in maps.
 
-  For instance, given a user map with the `:name` and `:languages`
-  keys, here is how to deeply traverse the map and convert all
-  language names to uppercase:
+  As mentioned above, this works for atom keys in maps as well. Refer to the
+  `Map` module for more information on this.
 
-      iex> languages = [
-      ...>   %{name: "elixir", type: :functional},
-      ...>   %{name: "c", type: :procedural}
-      ...> ]
-      iex> user = %{name: "john", languages: languages}
-      iex> update_in(user, [:languages, Access.all(), :name], &String.upcase/1)
-      %{
-        name: "john",
-        languages: [
-          %{name: "ELIXIR", type: :functional},
-          %{name: "C", type: :procedural}
-        ]
-      }
+  Summing up:
+
+    * `user[:name]` is used by dynamic structures, is extensible and
+      does not raise on missing keys
+    * `user.name` is used by static structures, it is not extensible
+      and it will raise on missing keys
+
+  ## Accessors
+
+  While Elixir provides built-in syntax only for traversing dynamic
+  and static key-value structures, this module provides convenience
+  functions for traversing other structures, like tuples and lists,
+  to be used alongside `Kernel.put_in/2` in others.
+
+  For instance, given a user with a list of languages, here is how to
+  deeply traverse the map and convert all language names to uppercase:
+
+      iex> user = %{name: "john",
+      ...>          languages: [%{name: "elixir", type: :functional},
+      ...>                      %{name: "c", type: :procedural}]}
+      iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
+      %{name: "john",
+        languages: [%{name: "ELIXIR", type: :functional},
+                    %{name: "C", type: :procedural}]}
+
+  See the functions `key/1`, `key!/1`, `elem/1`, and `all/0` for some of the
+  available accessors.
+
+  ## Implementing the Access behaviour for custom data structures
+
+  In order to be able to use the `Access` protocol with custom data structures
+  (which have to be structs), such structures have to implement the `Access`
+  behaviour. For example, for a `User` struct, this would have to be done:
+
+      defmodule User do
+        defstruct [:name, :email]
+
+        @behaviour Access
+        # Implementation of the Access callbacks...
+      end
 
-  See the functions `key/1`, `key!/1`, `elem/1`, and `all/0` for
-  some of the available accessors.
   """
 
-  @type container :: keyword | struct | map
-  @type nil_container :: nil
-  @type any_container :: any
-  @type t :: container | nil_container | any_container
+  @type t :: list | map | nil | any
   @type key :: any
   @type value :: any
 
-  @type get_fun(data, get_value) ::
-          (:get, data, (term -> term) ->
-             {get_value, new_data :: container})
-
-  @type get_and_update_fun(data, get_value) ::
-          (:get_and_update, data, (term -> term) ->
-             {get_value, new_data :: container} | :pop)
-
-  @type access_fun(data, get_value) ::
-          get_fun(data, get_value) | get_and_update_fun(data, get_value)
-
   @doc """
   Invoked in order to access the value stored under `key` in the given term `term`.
 
   This function should return `{:ok, value}` where `value` is the value under
-  `key` if the key exists in the term, or `:error` if the key does not exist in
-  the term.
+  `key` if it succeeded, or `:error` if the key does not exist in the structure.
 
   Many of the functions defined in the `Access` module internally call this
   function. This function is also used when the square-brackets access syntax
@@ -125,232 +153,148 @@ defmodule Access do
   value}` then `value` is returned, or if it returns `:error` then `nil` is
   returned.
 
+
   See the `Map.fetch/2` and `Keyword.fetch/2` implementations for examples of
   how to implement this callback.
   """
   @callback fetch(term :: t, key) :: {:ok, value} | :error
 
+  @doc """
+  Invoked in order to access the value stored under `key` in the given term `term`,
+  defaulting to `default` if not present.
+
+  This function should return the value under the key `key` in `term` if there's
+  such key, otherwise `default`.
+
+  For most data structures, this can be implemented using `fetch/2` internally;
+  for example:
+
+      def get(structure, key, default) do
+        case fetch(structure, key) do
+          {:ok, value} -> value
+          :error       -> default
+        end
+      end
+
+  See the `Map.get/3` and `Keyword.get/3` implementations for more examples.
+  """
+  @callback get(term :: t, key, default :: value) :: value
+
   @doc """
   Invoked in order to access the value under `key` and update it at the same time.
 
-  The implementation of this callback should invoke `fun` with the value under
-  `key` in the passed structure `data`, or with `nil` if `key` is not present in it.
-  This function must return either `{get_value, update_value}` or `:pop`.
+  The implementation of this callback should invoke the passed function with the
+  value under key `key` in the passed structure, or `nil` if the key is not
+  present. This function should return either `{value_to_return, new_value}` or
+  `:pop`.
 
-  If the passed function returns `{get_value, update_value}`,
-  the return value of this callback should be `{get_value, new_data}`, where:
+  If it returns `{value_to_return, new_value}`, the return value of this
+  callback should be `{value_to_return, new_term}` where `new_term` is `term`
+  after updating the value of `key` with `new_value`.
 
-    * `get_value` is the retrieved value (which can be operated on before being returned)
-
-    * `update_value` is the new value to be stored under `key`
-
-    * `new_data` is `data` after updating the value of `key` with `update_value`.
-
-  If the passed function returns `:pop`, the return value of this callback
-  must be `{value, new_data}` where `value` is the value under `key`
-  (or `nil` if not present) and `new_data` is `data` without `key`.
+  If it returns `:pop`, the return value of this callback should be `{value,
+  new_term}` where `value` is the value under `key` or `nil` if not present, and
+  `new_term` is `term` without the key `key`.
 
   See the implementations of `Map.get_and_update/3` or `Keyword.get_and_update/3`
   for more examples.
   """
-  @callback get_and_update(data, key, (value -> {get_value, value} | :pop)) :: {get_value, data}
-            when get_value: var, data: container | any_container
+  @callback get_and_update(term :: t, key, (value -> {value, value} | :pop)) :: {value, t}
 
   @doc """
-  Invoked to "pop" the value under `key` out of the given data structure.
+  Invoked to "pop" the value under `key` out of the given term.
 
-  When `key` exists in the given structure `data`, the implementation should
-  return a `{value, new_data}` tuple where `value` is the value that was under
-  `key` and `new_data` is `term` without `key`.
+  When the key `key` exists in the given `term`, the implementation should
+  return a `{value, new_term}` tuple where `value` is the value that was under
+  `key` and `new_term` is `term` without `key`.
 
-  When `key` is not present in the given structure, a tuple `{value, data}`
+  When the key `key` is not present in the given `term`, a tuple `{value, term}`
   should be returned, where `value` is implementation-defined.
 
   See the implementations for `Map.pop/3` or `Keyword.pop/3` for more examples.
   """
-  @callback pop(data, key) :: {value, data} when data: container | any_container
+  @callback pop(term :: t, key) :: {value, t}
 
-  defmacrop raise_undefined_behaviour(exception, module, top) do
+  defmacrop raise_undefined_behaviour(e, struct, top) do
     quote do
-      exception =
-        case __STACKTRACE__ do
+      stacktrace = System.stacktrace
+      e =
+        case stacktrace do
           [unquote(top) | _] ->
-            reason = "#{inspect(unquote(module))} does not implement the Access behaviour"
-            %{unquote(exception) | reason: reason}
-
+            %{unquote(e) | reason: "#{inspect unquote(struct)} does not implement the Access behaviour"}
           _ ->
-            unquote(exception)
+            unquote(e)
         end
-
-      reraise exception, __STACKTRACE__
+      reraise e, stacktrace
     end
   end
 
   @doc """
   Fetches the value for the given key in a container (a map, keyword
   list, or struct that implements the `Access` behaviour).
-
-  Returns `{:ok, value}` where `value` is the value under `key` if there is such
-  a key, or `:error` if `key` is not found.
-
-  ## Examples
-
-      iex> Access.fetch(%{name: "meg", age: 26}, :name)
-      {:ok, "meg"}
-
-      iex> Access.fetch([ordered: true, on_timeout: :exit], :timeout)
-      :error
-
   """
-  @spec fetch(container, term) :: {:ok, term} | :error
-  @spec fetch(nil_container, any) :: :error
+  @spec fetch(t, term) :: {:ok, term} | :error
   def fetch(container, key)
 
-  def fetch(%module{} = container, key) do
-    module.fetch(container, key)
+  def fetch(%{__struct__: struct} = container, key) do
+    struct.fetch(container, key)
   rescue
-    exception in UndefinedFunctionError ->
-      raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})
+    e in UndefinedFunctionError ->
+      raise_undefined_behaviour e, struct, {^struct, :fetch, [^container, ^key], _}
   end
 
   def fetch(map, key) when is_map(map) do
-    case map do
-      %{^key => value} -> {:ok, value}
-      _ -> :error
-    end
+    Map.fetch(map, key)
   end
 
   def fetch(list, key) when is_list(list) and is_atom(key) do
-    case :lists.keyfind(key, 1, list) do
-      {_, value} -> {:ok, value}
-      false -> :error
-    end
+    Keyword.fetch(list, key)
   end
 
   def fetch(list, key) when is_list(list) do
     raise ArgumentError,
-          "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
+      "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
   end
 
   def fetch(nil, _key) do
     :error
   end
 
-  @doc """
-  Same as `fetch/2` but returns the value directly,
-  or raises a `KeyError` exception if `key` is not found.
-
-  ## Examples
-
-      iex> Access.fetch!(%{name: "meg", age: 26}, :name)
-      "meg"
-
-  """
-  @doc since: "1.10.0"
-  @spec fetch!(container, term) :: term
-  def fetch!(container, key) do
-    case fetch(container, key) do
-      {:ok, value} -> value
-      :error -> raise(KeyError, key: key, term: container)
-    end
-  end
-
   @doc """
   Gets the value for the given key in a container (a map, keyword
   list, or struct that implements the `Access` behaviour).
-
-  Returns the value under `key` if there is such a key, or `default` if `key` is
-  not found.
-
-  ## Examples
-
-      iex> Access.get(%{name: "john"}, :name, "default name")
-      "john"
-      iex> Access.get(%{name: "john"}, :age, 25)
-      25
-
-      iex> Access.get([ordered: true], :timeout)
-      nil
-
   """
-  @spec get(container, term, term) :: term
-  @spec get(nil_container, any, default) :: default when default: var
-  def get(container, key, default \\ nil)
-
-  # Reimplementing the same logic as Access.fetch/2 here is done for performance, since
-  # this is called a lot and calling fetch/2 means introducing some overhead (like
-  # building the "{:ok, _}" tuple and deconstructing it back right away).
-
-  def get(%module{} = container, key, default) do
-    try do
-      module.fetch(container, key)
-    rescue
-      exception in UndefinedFunctionError ->
-        raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})
-    else
+  @spec get(t, term, term) :: term
+  def get(container, key, default \\ nil) do
+    case fetch(container, key) do
       {:ok, value} -> value
       :error -> default
     end
   end
 
-  def get(map, key, default) when is_map(map) do
-    case map do
-      %{^key => value} -> value
-      _ -> default
-    end
-  end
-
-  def get(list, key, default) when is_list(list) and is_atom(key) do
-    case :lists.keyfind(key, 1, list) do
-      {_, value} -> value
-      false -> default
-    end
-  end
-
-  def get(list, key, _default) when is_list(list) do
-    raise ArgumentError,
-          "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
-  end
-
-  def get(nil, _key, default) do
-    default
-  end
-
   @doc """
-  Gets and updates the given key in a `container` (a map, a keyword list,
-  a struct that implements the `Access` behaviour).
+  Gets and updates the given key in a container (a map, keyword
+  list, or struct that implements the `Access` behaviour).
 
-  The `fun` argument receives the value of `key` (or `nil` if `key` is not
-  present in `container`) and must return a two-element tuple `{get_value, update_value}`:
-  the "get" value `get_value` (the retrieved value, which can be operated on before
-  being returned) and the new value to be stored under `key` (`update_value`).
-  `fun` may also return `:pop`, which means the current value
-  should be removed from the container and returned.
+  This `fun` argument receives the value of `key` (or `nil` if `key`
+  is not present) and must return a two-element tuple: the "get" value
+  (the retrieved value, which can be operated on before being returned)
+  and the new value to be stored under `key`. The `fun` may also
+  return `:pop`, implying the current value shall be removed
+  from the container and returned.
 
   The returned value is a two-element tuple with the "get" value returned by
   `fun` and a new container with the updated value under `key`.
-
-  ## Examples
-
-      iex> Access.get_and_update([a: 1], :a, fn current_value ->
-      ...>   {current_value, current_value + 1}
-      ...> end)
-      {1, [a: 2]}
-
   """
-  @spec get_and_update(data, key, (value -> {get_value, value} | :pop)) :: {get_value, data}
-        when get_value: var, data: container
+  @spec get_and_update(container :: t, key, (value -> {get_value, update_value} | :pop)) ::
+        {get_value, container :: t} when get_value: var, update_value: value
   def get_and_update(container, key, fun)
 
-  def get_and_update(%module{} = container, key, fun) do
-    module.get_and_update(container, key, fun)
+  def get_and_update(%{__struct__: struct} = container, key, fun) do
+    struct.get_and_update(container, key, fun)
   rescue
-    exception in UndefinedFunctionError ->
-      raise_undefined_behaviour(
-        exception,
-        module,
-        {^module, :get_and_update, [^container, ^key, ^fun], _}
-      )
+    e in UndefinedFunctionError ->
+      raise_undefined_behaviour e, struct, {^struct, :get_and_update, [^container, ^key, ^fun], _}
   end
 
   def get_and_update(map, key, fun) when is_map(map) do
@@ -362,7 +306,8 @@ defmodule Access do
   end
 
   def get_and_update(nil, key, _fun) do
-    raise ArgumentError, "could not put/update key #{inspect(key)} on a nil value"
+    raise ArgumentError,
+      "could not put/update key #{inspect key} on a nil value"
   end
 
   @doc """
@@ -391,12 +336,11 @@ defmodule Access do
       {nil, %{creator: "Valim", name: "Elixir"}}
 
   """
-  @spec pop(data, key) :: {value, data} when data: container
-  def pop(%module{} = container, key) do
-    module.pop(container, key)
+  def pop(%{__struct__: struct} = container, key) do
+    struct.pop(container, key)
   rescue
-    exception in UndefinedFunctionError ->
-      raise_undefined_behaviour(exception, module, {^module, :pop, [^container, ^key], _})
+    e in UndefinedFunctionError ->
+      raise_undefined_behaviour e, struct, {^struct, :pop, [^container, ^key], _}
   end
 
   def pop(map, key) when is_map(map) do
@@ -408,11 +352,34 @@ defmodule Access do
   end
 
   def pop(nil, key) do
-    raise ArgumentError, "could not pop key #{inspect(key)} on a nil value"
+    raise ArgumentError,
+      "could not pop key #{inspect key} on a nil value"
   end
 
   ## Accessors
 
+  @doc false
+  def key(key) do
+    IO.warn "Access.key/1 is deprecated due to erratic behaviour for missing keys, " <>
+            "please use Access.key/2 instead with proper default values " <>
+            "(or Access.key!/1 if you expect the key to always be available)"
+
+    fn
+      :get, data, next ->
+        next.(Map.get(to_map(data), key))
+      :get_and_update, data, next ->
+        value = Map.get(to_map(data), key)
+        case next.(value) do
+          {get, update} -> {get, Map.put(data, key, update)}
+          :pop -> {value, Map.delete(data, key)}
+        end
+    end
+  end
+
+  defp to_map(nil), do: %{}
+  defp to_map(%{} = map), do: map
+  defp to_map(data), do: raise "Access.key/1 expected a map/struct or nil, got: #{inspect data}"
+
   @doc """
   Returns a function that accesses the given key in a map/struct.
 
@@ -422,13 +389,13 @@ defmodule Access do
   The returned function uses the default value if the key does not exist.
   This can be used to specify defaults and safely traverse missing keys:
 
-      iex> get_in(%{}, [Access.key(:user, %{name: "meg"}), Access.key(:name)])
-      "meg"
+      iex> get_in(%{}, [Access.key(:user, %{}), Access.key(:name, nil)])
+      nil
 
   Such is also useful when using update functions, allowing us to introduce
-  values as we traverse the data structure for updates:
+  values as we traverse the data-structure for updates:
 
-      iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name)], "Mary")
+      iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name, nil)], "Mary")
       %{user: %{name: "Mary"}}
 
   ## Examples
@@ -436,31 +403,28 @@ defmodule Access do
       iex> map = %{user: %{name: "john"}}
       iex> get_in(map, [Access.key(:unknown, %{}), Access.key(:name, "john")])
       "john"
-      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key(:user), Access.key(:name)])
+      iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
       {"john", %{user: %{}}}
 
   An error is raised if the accessed structure is not a map or a struct:
 
-      iex> get_in(nil, [Access.key(:foo)])
+      iex> get_in(nil, [Access.key(:foo, nil)])
       ** (BadMapError) expected a map, got: nil
 
-      iex> get_in([], [Access.key(:foo)])
+      iex> get_in([], [Access.key(:foo, nil)])
       ** (BadMapError) expected a map, got: []
 
   """
-  @spec key(key, term) :: access_fun(data :: struct | map, get_value :: term)
-  def key(key, default \\ nil) do
+  def key(key, default) do
     fn
       :get, data, next ->
         next.(Map.get(data, key, default))
-
       :get_and_update, data, next ->
         value = Map.get(data, key, default)
-
         case next.(value) do
           {get, update} -> {get, Map.put(data, key, update)}
           :pop -> {value, Map.delete(data, key)}
@@ -474,15 +438,15 @@ defmodule Access do
   The returned function is typically passed as an accessor to `Kernel.get_in/2`,
   `Kernel.get_and_update_in/3`, and friends.
 
-  Similar to `key/2`, but the returned function raises if the key does not exist.
+  Raises if the key does not exist.
 
   ## Examples
 
       iex> map = %{user: %{name: "john"}}
       iex> get_in(map, [Access.key!(:user), Access.key!(:name)])
       "john"
-      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", %{user: %{name: "JOHN"}}}
       iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
@@ -496,22 +460,18 @@ defmodule Access do
       ** (RuntimeError) Access.key!/1 expected a map/struct, got: []
 
   """
-  @spec key!(key) :: access_fun(data :: struct | map, get_value :: term)
   def key!(key) do
     fn
       :get, %{} = data, next ->
         next.(Map.fetch!(data, key))
-
       :get_and_update, %{} = data, next ->
         value = Map.fetch!(data, key)
-
         case next.(value) do
           {get, update} -> {get, Map.put(data, key, update)}
           :pop -> {value, Map.delete(data, key)}
         end
-
       _op, data, _next ->
-        raise "Access.key!/1 expected a map/struct, got: #{inspect(data)}"
+        raise "Access.key!/1 expected a map/struct, got: #{inspect data}"
     end
   end
 
@@ -521,18 +481,15 @@ defmodule Access do
   The returned function is typically passed as an accessor to `Kernel.get_in/2`,
   `Kernel.get_and_update_in/3`, and friends.
 
-  The returned function raises if `index` is out of bounds.
-
-  Note that popping elements out of tuples is not possible and raises an
-  error.
+  Raises if the index is out of bounds.
 
   ## Examples
 
       iex> map = %{user: {"john", 27}}
       iex> get_in(map, [:user, Access.elem(0)])
       "john"
-      iex> get_and_update_in(map, [:user, Access.elem(0)], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(map, [:user, Access.elem(0)], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", %{user: {"JOHN", 27}}}
       iex> pop_in(map, [:user, Access.elem(0)])
@@ -544,24 +501,20 @@ defmodule Access do
       ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}
 
   """
-  @spec elem(non_neg_integer) :: access_fun(data :: tuple, get_value :: term)
-  def elem(index) when is_integer(index) and index >= 0 do
+  def elem(index) when is_integer(index) do
     pos = index + 1
 
     fn
       :get, data, next when is_tuple(data) ->
         next.(:erlang.element(pos, data))
-
       :get_and_update, data, next when is_tuple(data) ->
         value = :erlang.element(pos, data)
-
         case next.(value) do
           {get, update} -> {get, :erlang.setelement(pos, data, update)}
           :pop -> raise "cannot pop data from a tuple"
         end
-
       _op, data, _next ->
-        raise "Access.elem/1 expected a tuple, got: #{inspect(data)}"
+        raise "Access.elem/1 expected a tuple, got: #{inspect data}"
     end
   end
 
@@ -576,19 +529,19 @@ defmodule Access do
       iex> list = [%{name: "john"}, %{name: "mary"}]
       iex> get_in(list, [Access.all(), :name])
       ["john", "mary"]
-      iex> get_and_update_in(list, [Access.all(), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(list, [Access.all(), :name], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
       iex> pop_in(list, [Access.all(), :name])
       {["john", "mary"], [%{}, %{}]}
 
   Here is an example that traverses the list dropping even
-  numbers and multiplying odd numbers by 2:
+  numbers and multipling odd numbers by 2:
 
       iex> require Integer
-      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all()], fn num ->
-      ...>   if Integer.is_even(num), do: :pop, else: {num, num * 2}
+      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn
+      ...>   num -> if Integer.is_even(num), do: :pop, else: {num, num * 2}
       ...> end)
       {[1, 2, 3, 4, 5], [2, 6, 10]}
 
@@ -598,7 +551,6 @@ defmodule Access do
       ** (RuntimeError) Access.all/0 expected a list, got: %{}
 
   """
-  @spec all() :: access_fun(data :: list, get_value :: list)
   def all() do
     &all/3
   end
@@ -608,11 +560,11 @@ defmodule Access do
   end
 
   defp all(:get_and_update, data, next) when is_list(data) do
-    all(data, next, _gets = [], _updates = [])
+    all(data, next, [], [])
   end
 
   defp all(_op, data, _next) do
-    raise "Access.all/0 expected a list, got: #{inspect(data)}"
+    raise "Access.all/0 expected a list, got: #{inspect data}"
   end
 
   defp all([head | rest], next, gets, updates) do
@@ -637,16 +589,10 @@ defmodule Access do
       iex> list = [%{name: "john"}, %{name: "mary"}]
       iex> get_in(list, [Access.at(1), :name])
       "mary"
-      iex> get_in(list, [Access.at(-1), :name])
-      "mary"
-      iex> get_and_update_in(list, [Access.at(0), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(list, [Access.at(0), :name], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", [%{name: "JOHN"}, %{name: "mary"}]}
-      iex> get_and_update_in(list, [Access.at(-1), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {"mary", [%{name: "john"}, %{name: "MARY"}]}
 
   `at/1` can also be used to pop elements out of a list or
   a key inside of a list:
@@ -662,20 +608,23 @@ defmodule Access do
       iex> list = [%{name: "john"}, %{name: "mary"}]
       iex> get_in(list, [Access.at(10), :name])
       nil
-      iex> get_and_update_in(list, [Access.at(10), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(list, [Access.at(10), :name], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {nil, [%{name: "john"}, %{name: "mary"}]}
 
+  An error is raised for negative indexes:
+
+      iex> get_in([], [Access.at(-1)])
+      ** (FunctionClauseError) no function clause matching in Access.at/1
+
   An error is raised if the accessed structure is not a list:
 
       iex> get_in(%{}, [Access.at(1)])
       ** (RuntimeError) Access.at/1 expected a list, got: %{}
-
   """
-  @spec at(integer) :: access_fun(data :: list, get_value :: term)
-  def at(index) when is_integer(index) do
-    fn op, data, next -> at(op, data, index, next) end
+  def at(index) when index >= 0 do
+    fn(op, data, next) -> at(op, data, index, next) end
   end
 
   defp at(:get, data, index, next) when is_list(data) do
@@ -687,7 +636,7 @@ defmodule Access do
   end
 
   defp at(_op, data, _index, _next) do
-    raise "Access.at/1 expected a list, got: #{inspect(data)}"
+    raise "Access.at/1 expected a list, got: #{inspect data}"
   end
 
   defp get_and_update_at([head | rest], 0, next, updates) do
@@ -697,103 +646,11 @@ defmodule Access do
     end
   end
 
-  defp get_and_update_at(list, index, next, updates) when index < 0 do
-    list_length = length(list)
-
-    if list_length + index >= 0 do
-      get_and_update_at(list, list_length + index, next, updates)
-    else
-      {nil, list}
-    end
-  end
-
-  defp get_and_update_at([head | rest], index, next, updates) when index > 0 do
+  defp get_and_update_at([head | rest], index, next, updates) do
     get_and_update_at(rest, index - 1, next, [head | updates])
   end
 
   defp get_and_update_at([], _index, _next, updates) do
     {nil, :lists.reverse(updates)}
   end
-
-  @doc ~S"""
-  Returns a function that accesses all elements of a list that match the provided predicate.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  ## Examples
-
-      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
-      iex> get_in(list, [Access.filter(&(&1.salary > 20)), :name])
-      ["francine"]
-      iex> get_and_update_in(list, [Access.filter(&(&1.salary <= 20)), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {["john"], [%{name: "JOHN", salary: 10}, %{name: "francine", salary: 30}]}
-
-  `filter/1` can also be used to pop elements out of a list or
-  a key inside of a list:
-
-      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
-      iex> pop_in(list, [Access.filter(&(&1.salary >= 20))])
-      {[%{name: "francine", salary: 30}], [%{name: "john", salary: 10}]}
-      iex> pop_in(list, [Access.filter(&(&1.salary >= 20)), :name])
-      {["francine"], [%{name: "john", salary: 10}, %{salary: 30}]}
-
-  When no match is found, an empty list is returned and the update function is never called
-
-      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
-      iex> get_in(list, [Access.filter(&(&1.salary >= 50)), :name])
-      []
-      iex> get_and_update_in(list, [Access.filter(&(&1.salary >= 50)), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}
-
-  An error is raised if the predicate is not a function or is of the incorrect arity:
-
-      iex> get_in([], [Access.filter(5)])
-      ** (FunctionClauseError) no function clause matching in Access.filter/1
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.filter(fn a -> a == 10 end)])
-      ** (RuntimeError) Access.filter/1 expected a list, got: %{}
-
-  """
-  @doc since: "1.6.0"
-  @spec filter((term -> boolean)) :: access_fun(data :: list, get_value :: list)
-  def filter(func) when is_function(func) do
-    fn op, data, next -> filter(op, data, func, next) end
-  end
-
-  defp filter(:get, data, func, next) when is_list(data) do
-    data |> Enum.filter(func) |> Enum.map(next)
-  end
-
-  defp filter(:get_and_update, data, func, next) when is_list(data) do
-    get_and_update_filter(data, func, next, [], [])
-  end
-
-  defp filter(_op, data, _func, _next) do
-    raise "Access.filter/1 expected a list, got: #{inspect(data)}"
-  end
-
-  defp get_and_update_filter([head | rest], func, next, updates, gets) do
-    if func.(head) do
-      case next.(head) do
-        {get, update} ->
-          get_and_update_filter(rest, func, next, [update | updates], [get | gets])
-
-        :pop ->
-          get_and_update_filter(rest, func, next, updates, [head | gets])
-      end
-    else
-      get_and_update_filter(rest, func, next, [head | updates], gets)
-    end
-  end
-
-  defp get_and_update_filter([], _func, _next, updates, gets) do
-    {:lists.reverse(gets), :lists.reverse(updates)}
-  end
 end

lib/elixir/lib/agent.ex

@@ -6,55 +6,48 @@ defmodule Agent do
   must be accessed from different processes or by the same process
   at different points in time.
 
-  The `Agent` module provides a basic server implementation that
+  The Agent module provides a basic server implementation that
   allows state to be retrieved and updated via a simple API.
 
   ## Examples
 
-  For example, the following agent implements a counter:
+  For example, in the Mix tool that ships with Elixir, we need
+  to keep a set of all tasks executed by a given project. Since
+  this set is shared, we can implement it with an Agent:
 
-      defmodule Counter do
-        use Agent
-
-        def start_link(initial_value) do
-          Agent.start_link(fn -> initial_value end, name: __MODULE__)
+      defmodule Mix.TasksServer do
+        def start_link do
+          Agent.start_link(fn -> MapSet.new end, name: __MODULE__)
         end
 
-        def value do
-          Agent.get(__MODULE__, & &1)
+        @doc "Checks if the task has already executed"
+        def executed?(task, project) do
+          item = {task, project}
+          Agent.get(__MODULE__, fn set ->
+            item in set
+          end)
         end
 
-        def increment do
-          Agent.update(__MODULE__, &(&1 + 1))
+        @doc "Marks a task as executed"
+        def put_task(task, project) do
+          item = {task, project}
+          Agent.update(__MODULE__, &MapSet.put(&1, item))
+        end
+
+        @doc "Resets the executed tasks and returns the previous list of tasks"
+        def take_all() do
+          Agent.get_and_update(__MODULE__, fn set ->
+            {Enum.into(set, []), MapSet.new}
+          end)
         end
       end
 
-  Usage would be:
-
-      Counter.start_link(0)
-      #=> {:ok, #PID<0.123.0>}
-
-      Counter.value()
-      #=> 0
-
-      Counter.increment()
-      #=> :ok
-
-      Counter.increment()
-      #=> :ok
-
-      Counter.value()
-      #=> 2
-
-  Thanks to the agent server process, the counter can be safely incremented
-  concurrently.
-
-  Agents provide a segregation between the client and server APIs (similar to
-  `GenServer`s). In particular, the functions passed as arguments to the calls to
-  `Agent` functions are invoked inside the agent (the server). This distinction
-  is important because you may want to avoid expensive operations inside the
-  agent, as they will effectively block the agent until the request is
-  fulfilled.
+  Note that agents still provide a segregation between the
+  client and server APIs, as seen in GenServers. In particular,
+  all code inside the function passed to the agent is executed
+  by the agent. This distinction is important because you may
+  want to avoid expensive operations inside the agent, as it will
+  effectively block the agent until the request is fulfilled.
 
   Consider these two examples:
 
@@ -65,79 +58,19 @@ defmodule Agent do
 
       # Compute in the agent/client
       def get_something(agent) do
-        Agent.get(agent, & &1) |> do_something_expensive()
+        Agent.get(agent, &(&1)) |> do_something_expensive()
       end
 
-  The first function blocks the agent. The second function copies all the state
-  to the client and then executes the operation in the client. One aspect to
-  consider is whether the data is large enough to require processing in the server,
-  at least initially, or small enough to be sent to the client cheaply. Another
-  factor is whether the data needs to be processed atomically: getting the
-  state and calling `do_something_expensive(state)` outside of the agent means
-  that the agent's state can be updated in the meantime. This is specially
-  important in case of updates as computing the new state in the client rather
-  than in the server can lead to race conditions if multiple clients are trying
-  to update the same state to different values.
+  The first function blocks the agent. The second function copies
+  all the state to the client and then executes the operation in the
+  client. The difference is whether the data is large enough to require
+  processing in the server, at least initially, or small enough to be
+  sent to the client cheaply.
 
-  ## How to supervise
+  ## Name Registration
 
-  An `Agent` is most commonly started under a supervision tree.
-  When we invoke `use Agent`, it automatically defines a `child_spec/1`
-  function that allows us to start the agent directly under a supervisor.
-  To start an agent under a supervisor with an initial counter of 0,
-  one may do:
-
-      children = [
-        {Counter, 0}
-      ]
-
-      Supervisor.start_link(children, strategy: :one_for_all)
-
-  While one could also simply pass the `Counter` as a child to the supervisor,
-  such as:
-
-      children = [
-        Counter # Same as {Counter, []}
-      ]
-
-      Supervisor.start_link(children, strategy: :one_for_all)
-
-  The definition above wouldn't work for this particular example,
-  as it would attempt to start the counter with an initial value
-  of an empty list. However, this may be a viable option in your
-  own agents. A common approach is to use a keyword list, as that
-  would allow setting the initial value and giving a name to the
-  counter process, for example:
-
-      def start_link(opts) do
-        {initial_value, opts} = Keyword.pop(opts, :initial_value, 0)
-        Agent.start_link(fn -> initial_value end, opts)
-      end
-
-  and then you can use `Counter`, `{Counter, name: :my_counter}` or
-  even `{Counter, initial_value: 0, name: :my_counter}` as a child
-  specification.
-
-  `use Agent` also accepts a list of options which configures the
-  child specification and therefore how it runs under a supervisor.
-  The generated `child_spec/1` can be customized with the following options:
-
-    * `:id` - the child specification identifier, defaults to the current module
-    * `:restart` - when the child should be restarted, defaults to `:permanent`
-    * `:shutdown` - how to shut down the child, either immediately or by giving it time to shut down
-
-  For example:
-
-      use Agent, restart: :transient, shutdown: 10_000
-
-  See the "Child specification" section in the `Supervisor` module for more
-  detailed information. The `@doc` annotation immediately preceding
-  `use Agent` will be attached to the generated `child_spec/1` function.
-
-  ## Name registration
-
-  An agent is bound to the same name registration rules as GenServers.
-  Read more about it in the `GenServer` documentation.
+  An Agent is bound to the same name registration rules as GenServers.
+  Read more about it in the `GenServer` docs.
 
   ## A word on distributed agents
 
@@ -162,15 +95,14 @@ defmodule Agent do
   ## Hot code swapping
 
   An agent can have its code hot swapped live by simply passing a module,
-  function, and arguments tuple to the update instruction. For example, imagine
+  function, and args tuple to the update instruction. For example, imagine
   you have an agent named `:sample` and you want to convert its inner state
-  from a keyword list to a map. It can be done with the following
+  from some dict structure to a map. It can be done with the following
   instruction:
 
       {:update, :sample, {:advanced, {Enum, :into, [%{}]}}}
 
-  The agent's state will be added to the given list of arguments (`[%{}]`) as
-  the first argument.
+  The agent's state will be added to the given list as the first argument.
   """
 
   @typedoc "Return values of `start*` functions"
@@ -185,51 +117,14 @@ defmodule Agent do
   @typedoc "The agent state"
   @type state :: term
 
-  @doc """
-  Returns a specification to start an agent under a supervisor.
-
-  See the "Child specification" section in the `Supervisor` module for more detailed information.
-  """
-  @doc since: "1.5.0"
-  def child_spec(arg) do
-    %{
-      id: Agent,
-      start: {Agent, :start_link, [arg]}
-    }
-  end
-
-  @doc false
-  defmacro __using__(opts) do
-    quote location: :keep, bind_quoted: [opts: opts] do
-      unless Module.has_attribute?(__MODULE__, :doc) do
-        @doc """
-        Returns a specification to start this module under a supervisor.
-
-        See `Supervisor`.
-        """
-      end
-
-      def child_spec(arg) do
-        default = %{
-          id: __MODULE__,
-          start: {__MODULE__, :start_link, [arg]}
-        }
-
-        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
-      end
-
-      defoverridable child_spec: 1
-    end
-  end
-
   @doc """
   Starts an agent linked to the current process with the given function.
 
   This is often used to start the agent as part of a supervision tree.
 
-  Once the agent is spawned, the given function `fun` is invoked in the server
-  process, and should return the initial agent state. Note that `start_link/2`
-  does not return until the given function has returned.
+  Once the agent is spawned, the given function is invoked and its return
+  value is used as the agent state. Note that `start_link` does not return
+  until the given function has returned.
 
   ## Options
 
@@ -253,32 +148,22 @@ defmodule Agent do
   specified name already exists, the function returns
   `{:error, {:already_started, pid}}` with the PID of that process.
 
-  If the given function callback fails, the function returns `{:error, reason}`.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
-      iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise "oops" end)
-      iex> exception
-      %RuntimeError{message: "oops"}
-
+  If the given function callback fails with `reason`, the function returns
+  `{:error, reason}`.
   """
-  @spec start_link((() -> term), GenServer.options()) :: on_start
+  @spec start_link((() -> term), GenServer.options) :: on_start
   def start_link(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start_link(Agent.Server, fun, options)
   end
 
   @doc """
-  Starts an agent linked to the current process.
+  Starts an agent linked to the current process with the given module
+  function and arguments.
 
-  Same as `start_link/2` but a module, function, and arguments are expected
-  instead of an anonymous function; `fun` in `module` will be called with the
-  given arguments `args` to initialize the state.
+  Same as `start_link/2` but a module, function and args are expected
+  instead of an anonymous function.
   """
-  @spec start_link(module, atom, [any], GenServer.options()) :: on_start
+  @spec start_link(module, atom, [any], GenServer.options) :: on_start
   def start_link(module, fun, args, options \\ []) do
     GenServer.start_link(Agent.Server, {module, fun, args}, options)
   end
@@ -287,48 +172,31 @@ defmodule Agent do
   Starts an agent process without links (outside of a supervision tree).
 
   See `start_link/2` for more information.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
   """
-  @spec start((() -> term), GenServer.options()) :: on_start
+  @spec start((() -> term), GenServer.options) :: on_start
   def start(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start(Agent.Server, fun, options)
   end
 
   @doc """
-  Starts an agent without links with the given module, function, and arguments.
+  Starts an agent with the given module function and arguments.
 
-  See `start_link/4` for more information.
+  Similar to `start/2` but a module, function and args are expected
+  instead of an anonymous function.
   """
-  @spec start(module, atom, [any], GenServer.options()) :: on_start
+  @spec start(module, atom, [any], GenServer.options) :: on_start
   def start(module, fun, args, options \\ []) do
     GenServer.start(Agent.Server, {module, fun, args}, options)
   end
 
   @doc """
-  Gets an agent value via the given anonymous function.
+  Gets an agent value via the given function.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The result of the function invocation is
-  returned from this function.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
+  returned.
 
+  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get(agent, (state -> a), timeout) :: a when a: var
   def get(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -338,9 +206,9 @@ defmodule Agent do
   @doc """
   Gets an agent value via the given function.
 
-  Same as `get/3` but a module, function, and arguments are expected
+  Same as `get/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
   @spec get(agent, module, atom, [term], timeout) :: any
   def get(agent, module, fun, args, timeout \\ 5000) do
@@ -348,28 +216,14 @@ defmodule Agent do
   end
 
   @doc """
-  Gets and updates the agent state in one operation via the given anonymous
-  function.
+  Gets and updates the agent state in one operation.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The function must return a tuple with two
-  elements, the first being the value to return (that is, the "get" value)
-  and the second one being the new state of the agent.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)
-      42
-      iex> Agent.get(pid, fn state -> state end)
-      43
+  elements, the first being the value to return (i.e. the `get` value)
+  and the second one is the new state.
 
+  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get_and_update(agent, (state -> {a, state}), timeout) :: a when a: var
   def get_and_update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -377,11 +231,11 @@ defmodule Agent do
   end
 
   @doc """
-  Gets and updates the agent state in one operation via the given function.
+  Gets and updates the agent state in one operation.
 
-  Same as `get_and_update/3` but a module, function, and arguments are expected
+  Same as `get_and_update/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
   @spec get_and_update(agent, module, atom, [term], timeout) :: any
   def get_and_update(agent, module, fun, args, timeout \\ 5000) do
@@ -389,28 +243,13 @@ defmodule Agent do
   end
 
   @doc """
-  Updates the agent state via the given anonymous function.
+  Updates the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
+  passing the agent state. The function must return the new state.
 
+  A timeout can also be specified (it has a default value of 5000).
   This function always returns `:ok`.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.update(pid, fn state -> state + 1 end)
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      43
-
   """
   @spec update(agent, (state -> state), timeout) :: :ok
   def update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -418,20 +257,11 @@ defmodule Agent do
   end
 
   @doc """
-  Updates the agent state via the given function.
+  Updates the agent state.
 
-  Same as `update/3` but a module, function, and arguments are expected
+  Same as `update/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.update(pid, Kernel, :+, [12])
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      54
-
+  argument to the given list of args.
   """
   @spec update(agent, module, atom, [term], timeout) :: :ok
   def update(agent, module, fun, args, timeout \\ 5000) do
@@ -439,23 +269,13 @@ defmodule Agent do
   end
 
   @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
+  Performs a cast (fire and forget) operation on the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
-
-  Note that `cast` returns `:ok` immediately, regardless of whether `agent` (or
-  the node it should live on) exists.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.cast(pid, fn state -> state + 1 end)
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      43
+  passing the agent state. The function must return the new state.
 
+  Note that `cast` returns `:ok` immediately, regardless of whether the
+  destination node or agent exists.
   """
   @spec cast(agent, (state -> state)) :: :ok
   def cast(agent, fun) when is_function(fun, 1) do
@@ -463,20 +283,11 @@ defmodule Agent do
   end
 
   @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
+  Performs a cast (fire and forget) operation on the agent state.
 
-  Same as `cast/2` but a module, function, and arguments are expected
+  Same as `cast/2` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.cast(pid, Kernel, :+, [12])
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      54
-
+  argument to the given list of args.
   """
   @spec cast(agent, module, atom, [term]) :: :ok
   def cast(agent, module, fun, args) do
@@ -484,25 +295,18 @@ defmodule Agent do
   end
 
   @doc """
-  Synchronously stops the agent with the given `reason`.
+  Stops the agent with the given `reason`.
 
-  It returns `:ok` if the agent terminates with the given
-  reason. If the agent terminates with another reason, the call will
+  It returns `:ok` if the server terminates with the given
+  reason, if it terminates with another reason, the call will
   exit.
 
   This function keeps OTP semantics regarding error reporting.
   If the reason is any other than `:normal`, `:shutdown` or
   `{:shutdown, _}`, an error report will be logged.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.stop(pid)
-      :ok
-
   """
   @spec stop(agent, reason :: term, timeout) :: :ok
   def stop(agent, reason \\ :normal, timeout \\ :infinity) do
-    GenServer.stop(agent, reason, timeout)
+    :gen.stop(agent, reason, timeout)
   end
 end

lib/elixir/lib/agent/server.ex

@@ -15,7 +15,7 @@ defmodule Agent.Server do
   def handle_call({:get_and_update, fun}, _from, state) do
     case run(fun, [state]) do
       {reply, state} -> {:reply, reply, state}
-      other -> {:stop, {:bad_return_value, other}, state}
+      other          -> {:stop, {:bad_return_value, other}, state}
     end
   end
 
@@ -23,10 +23,18 @@ defmodule Agent.Server do
     {:reply, :ok, run(fun, [state])}
   end
 
+  def handle_call(msg, from, state) do
+    super(msg, from, state)
+  end
+
   def handle_cast({:cast, fun}, state) do
     {:noreply, run(fun, [state])}
   end
 
+  def handle_cast(msg, state) do
+    super(msg, state)
+  end
+
   def code_change(_old, state, fun) do
     {:ok, run(fun, [state])}
   end
@@ -37,8 +45,8 @@ defmodule Agent.Server do
   end
 
   defp get_initial_call(fun) when is_function(fun, 0) do
-    {:module, module} = Function.info(fun, :module)
-    {:name, name} = Function.info(fun, :name)
+    {:module, module} = :erlang.fun_info(fun, :module)
+    {:name, name} = :erlang.fun_info(fun, :name)
     {module, name, 0}
   end
 

lib/elixir/lib/application.ex

@@ -2,282 +2,98 @@ defmodule Application do
   @moduledoc """
   A module for working with applications and defining application callbacks.
 
-  Applications are the idiomatic way to package software in Erlang/OTP. To get
-  the idea, they are similar to the "library" concept common in other
-  programming languages, but with some additional characteristics.
+  In Elixir (actually, in Erlang/OTP), an application is a component
+  implementing some specific functionality, that can be started and stopped
+  as a unit, and which can be re-used in other systems.
 
-  An application is a component implementing some specific functionality, with a
-  standardized directory structure, configuration, and lifecycle. Applications
-  are *loaded*, *started*, and *stopped*. Each application also has its own
-  environment, which provides a unified API for configuring each application.
+  Applications are defined with an application file named `APP.app` where
+  `APP` is the application name, usually in `underscore_case`. The application
+  file must reside in the same `ebin` directory as the compiled modules of the
+  application.
 
-  Developers typically interact with the application environment and its
-  callback module. Therefore those will be the topics we will cover first
-  before jumping into details about the application resource file and life-cycle.
+  In Elixir, Mix is responsible for compiling your source code and
+  generating your application `.app` file. Furthermore, Mix is also
+  responsible for configuring, starting and stopping your application
+  and its dependencies. For this reason, this documentation will focus
+  on the remaining aspects of your application: the application environment
+  and the application callback module.
 
-  ## The application environment
+  You can learn more about Mix generation of `.app` files by typing
+  `mix help compile.app`.
 
-  Each application has its own environment. The environment is a keyword list
-  that maps atoms to terms. Note that this environment is unrelated to the
-  operating system environment.
+  ## Application environment
 
-  By default, the environment of an application is an empty list. In a Mix
-  project's `mix.exs` file, you can set the `:env` key in `application/0`:
+  Once an application is started, OTP provides an application environment
+  that can be used to configure the application.
+
+  Assuming you are inside a Mix project, you can edit the `application/0`
+  function in the `mix.exs` file to the following:
 
       def application do
-        [env: [db_host: "localhost"]]
+        [env: [hello: :world]]
       end
 
-  Now, in your application, you can read this environment by using functions
-  such as `fetch_env!/2` and friends:
+  In the application function, we can define the default environment values
+  for our application. By starting your application with `iex -S mix`, you
+  can access the default value:
 
-      defmodule MyApp.DBClient do
-        def start_link() do
-          SomeLib.DBClient.start_link(host: db_host())
-        end
+      Application.get_env(:APP_NAME, :hello)
+      #=> :world
 
-        defp db_host do
-          Application.fetch_env!(:my_app, :db_host)
-        end
-      end
+  It is also possible to put and delete values from the application value,
+  including new values that are not defined in the environment file (although
+  this should be avoided).
 
-  In Mix projects, the environment of the application and its dependencies can
-  be overridden via the `config/config.exs` file. For example, someone using
-  your application can override its `:db_host` environment variable as follows:
+  Keep in mind that each application is responsible for its environment.
+  Do not use the functions in this module for directly accessing or modifying
+  the environment of other applications (as it may lead to inconsistent
+  data in the application environment).
 
-      import Config
-      config :my_app, :db_host, "db.local"
+  ## Application module callback
 
-  You can also change the application environment dynamically by using functions
-  such as `put_env/3` and `delete_env/2`. However, as a rule of thumb, each application
-  is responsible for its own environment. Please do not use the functions in this
-  module for directly accessing or modifying the environment of other applications.
-
-  ### Compile-time environment
-
-  In the previous example, we read the application environment at runtime:
-
-      defmodule MyApp.DBClient do
-        def start_link() do
-          SomeLib.DBClient.start_link(host: db_host())
-        end
-
-        defp db_host do
-          Application.fetch_env!(:my_app, :db_host)
-        end
-      end
-
-  In other words, the environment key `:db_host` for application `:my_app`
-  will only be read when `MyApp.DBClient` effectively starts. 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 `get_env/3`
-  outside of a function:
-
-      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"
-
-  This value will have no effect as the code was compiled to connect to "db.local",
-  which is mostly likely unavailable in the production environment.
-
-  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, we recommend you to use `compile_env/3` instead:
-
-      @db_host Application.compile_env(:my_app, :db_host, "db.local")
-
-  By using `compile_env/3`, tools like Mix 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.
-
-  ## The application callback module
-
-  Applications can be loaded, started, and stopped. Generally, build tools
-  like Mix take care of starting an application and all of its dependencies
-  for you, but you can also do it manually by calling:
-
-      {:ok, _} = Application.ensure_all_started(:some_app)
-
-  When an application starts, developers may configure a callback module
-  that executes custom code. Developers use this callback to start the
-  application supervision tree.
-
-  The first step to do so is to add a `:mod` key to the `application/0`
-  definition in your `mix.exs` file. It expects a tuple, with the application
-  callback module and start argument (commonly an empty list):
+  Often times, an application defines a supervision tree that must be started
+  and stopped when the application starts and stops. For such, we need to
+  define an application module callback. The first step is to define the
+  module callback in the application definition in the `mix.exs` file:
 
       def application do
         [mod: {MyApp, []}]
       end
 
-  The `MyApp` module given to `:mod` needs to implement the `Application` behaviour.
-  This can be done by putting `use Application` in that module and implementing the
-  `c:start/2` callback, for example:
+  Our application now requires the `MyApp` module to provide an application
+  callback. This can be done by invoking `use Application` in that module and
+  defining a `start/2` callback, for example:
 
       defmodule MyApp do
         use Application
 
         def start(_type, _args) do
-          children = []
-          Supervisor.start_link(children, strategy: :one_for_one)
+          MyApp.Supervisor.start_link()
         end
       end
 
-  The `c:start/2` callback has to spawn and link a supervisor and return `{:ok,
-  pid}` or `{:ok, pid, state}`, where `pid` is the PID of the supervisor, and
-  `state` is an optional application state. `args` is the second element of the
-  tuple given to the `:mod` option.
+  `start/2` typically returns `{:ok, pid}` or `{:ok, pid, state}` where
+  `pid` identifies the supervision tree and `state` is the application state.
+  `args` is the second element of the tuple given to the `:mod` option.
 
-  The `type` argument passed to `c:start/2` is usually `:normal` unless in a
+  The `type` argument passed to `start/2` is usually `:normal` unless in a
   distributed setup where application takeovers and failovers are configured.
-  Distributed applications are beyond the scope of this documentation.
+  This particular aspect of applications is explained in more detail in the
+  OTP documentation:
 
-  When an application is shutting down, its `c:stop/1` callback is called after
-  the supervision tree has been stopped by the runtime. This callback allows the
-  application to do any final cleanup. The argument is the state returned by
-  `c:start/2`, if it did, or `[]` otherwise. The return value of `c:stop/1` is
-  ignored.
+    * [`:application` module](http://www.erlang.org/doc/man/application.html)
+    * [Applications – OTP Design Principles](http://www.erlang.org/doc/design_principles/applications.html)
 
-  By using `Application`, modules get a default implementation of `c:stop/1`
-  that ignores its argument and returns `:ok`, but it can be overridden.
-
-  Application callback modules may also implement the optional callback
-  `c:prep_stop/1`. If present, `c:prep_stop/1` is invoked before the supervision
-  tree is terminated. Its argument is the state returned by `c:start/2`, if it did,
-  or `[]` otherwise, and its return value is passed to `c:stop/1`.
-
-  ## The application resource file
-
-  In the sections above, we have configured an application in the
-  `application/0` section of the `mix.exs` file. Ultimately, Mix will use
-  this configuration to create an [*application resource
-  file*](http://erlang.org/doc/man/app.html), which is a file called
-  `APP_NAME.app`. For example, the application resource file of the OTP
-  application `ex_unit` is called `ex_unit.app`.
-
-  You can learn more about the generation of application resource files in
-  the documentation of `Mix.Tasks.Compile.App`, available as well by running
-  `mix help compile.app`.
-
-  ## The application lifecycle
-
-  ### Loading applications
-
-  Applications are *loaded*, which means that the runtime finds and processes
-  their resource files:
-
-      Application.load(:ex_unit)
-      #=> :ok
-
-  When an application is loaded, the environment specified in its resource file
-  is merged with any overrides from config files.
-
-  Loading an application *does not* load its modules.
-
-  In practice, you rarely load applications by hand because that is part of the
-  start process, explained next.
-
-  ### Starting applications
-
-  Applications are also *started*:
-
-      Application.start(:ex_unit)
-      #=> :ok
-
-  Once your application is compiled, running your system is a matter of starting
-  your current application and its dependencies. Differently from other languages,
-  Elixir does not have a `main` procedure that is responsible for starting your
-  system. Instead, you start one or more applications, each with their own
-  initialization and termination logic.
-
-  When an application is started, the `Application.load/1` is automatically
-  invoked if it hasn't been done yet. Then, it checks if the dependencies listed
-  in the `applications` key of the resource file are already started. Having at
-  least one dependency not started is an error condition. Functions like
-  `ensure_all_started/1` takes care of starting an application and all of its
-  dependencies for you.
-
-  If the application does not have a callback module configured, starting is
-  done at this point. Otherwise, its `c:start/2` callback if invoked. The PID of
-  the top-level supervisor returned by this function is stored by the runtime
-  for later use, and the returned application state is saved too, if any.
-
-  ### Stopping applications
-
-  Started applications are, finally, *stopped*:
-
-      Application.stop(:ex_unit)
-      #=> :ok
-
-  Stopping an application without a callback module is defined, but except for
-  some system tracing, it is in practice a no-op.
-
-  Stopping an application with a callback module has three steps:
-
-    1. If present, invoke the optional callback `c:prep_stop/1`.
-    2. Terminate the top-level supervisor.
-    3. Invoke the required callback `c:stop/1`.
-
-  The arguments passed to the callbacks are related to the state optionally
-  returned by `c:start/2`, and are documented in the section about the callback
-  module above.
-
-  It is important to highlight that step 2 is a blocking one. Termination of a
-  supervisor triggers a recursive chain of children terminations, therefore
-  orderly shutting down all descendant processes. The `c:stop/1` callback is
-  invoked only after termination of the whole supervision tree.
-
-  Shutting down a live system cleanly can be done by calling `System.stop/1`. It
-  will shut down every application in the opposite order they had been started.
-
-  By default, a SIGTERM from the operating system will automatically translate to
-  `System.stop/0`. You can also have more explicit control over operating system
-  signals via the `:os.set_signal/2` function.
-
-  ## Tooling
-
-  The Mix build tool automates most of the application management tasks. For example,
-  `mix test` automatically starts your application dependencies and your application
-  itself before your test runs. `mix run --no-halt` boots your current project and
-  can be used to start a long running system. See `mix help run`.
-
-  Developers can also use `mix release` to build **releases**. Releases are able to
-  package all of your source code as well as the Erlang VM into a single directory.
-  Releases also give you explicit control over how each application is started and in
-  which order. They also provide a more streamlined mechanism for starting and
-  stopping systems, debugging, logging, as well as system monitoring.
-
-  Finally, Elixir provides tools such as escripts and archives, which are
-  different mechanisms for packaging your application. Those are typically used
-  when tools must be shared between developers and not as deployment options.
-  See `mix help archive.build` and `mix help escript.build` for more detail.
-
-  ## Further information
-
-  For further details on applications please check the documentation of the
-  [`application`](http://www.erlang.org/doc/man/application.html) Erlang module,
-  and the
-  [Applications](http://www.erlang.org/doc/design_principles/applications.html)
-  section of the [OTP Design Principles User's
-  Guide](http://erlang.org/doc/design_principles/users_guide.html).
+  A developer may also implement the `stop/1` callback (automatically defined
+  by `use Application`) which does any application cleanup. It receives the
+  application state and can return any value. Note that shutting down the
+  supervisor is automatically handled by the VM.
   """
 
   @doc """
   Called when an application is started.
 
-  This function is called when an application is started using
+  This function is called when an the application is started using
   `Application.start/2` (and functions on top of that, such as
   `Application.ensure_started/2`). This function should start the top-level
   process of the application (which should be the top supervisor of the
@@ -288,7 +104,7 @@ defmodule Application do
 
     * `:normal` - used if the startup is a normal startup or if the application
       is distributed and is started on the current node because of a failover
-      from another node and the application specification key `:start_phases`
+      from another mode and the application specification key `:start_phases`
       is `:undefined`.
     * `{:takeover, node}` - used if the application is distributed and is
       started on the current node because of a failover on the node `node`.
@@ -297,7 +113,7 @@ defmodule Application do
       application specification key `:start_phases` is not `:undefined`.
 
   `start_args` are the arguments passed to the application in the `:mod`
-  specification key (for example, `mod: {MyApp, [:my_args]}`).
+  specification key (e.g., `mod: {MyApp, [:my_args]}`).
 
   This function should either return `{:ok, pid}` or `{:ok, pid, state}` if
   startup is successful. `pid` should be the PID of the top supervisor. `state`
@@ -309,60 +125,26 @@ defmodule Application do
   callback.
   """
   @callback start(start_type, start_args :: term) ::
-              {:ok, pid}
-              | {:ok, pid, state}
-              | {:error, reason :: term}
+    {:ok, pid} |
+    {:ok, pid, state} |
+    {:error, reason :: term}
 
   @doc """
-  Called before stopping the application.
+  Called when an application is stopped.
 
-  This function is called before the top-level supervisor is terminated. It
-  receives the state returned by `c:start/2`, if it did, or `[]` otherwise.
-  The return value is later passed to `c:stop/1`.
-  """
-  @callback prep_stop(state) :: state
-
-  @doc """
-  Called after an application has been stopped.
-
-  This function is called after an application has been stopped, i.e., after its
+  This function is called when an application has stopped, i.e., when its
   supervision tree has been stopped. It should do the opposite of what the
-  `c:start/2` callback did, and should perform any necessary cleanup. The return
+  `start/2` callback did, and should perform any necessary cleanup. The return
   value of this callback is ignored.
 
-  `state` is the state returned by `c:start/2`, if it did, or `[]` otherwise.
-  If the optional callback `c:prep_stop/1` is present, `state` is its return
-  value instead.
+  `state` is the return value of the `start/2` callback or the return value of
+  the `prep_stop/1` function if the application module defines such a function.
 
   `use Application` defines a default implementation of this function which does
   nothing and just returns `:ok`.
   """
   @callback stop(state) :: term
 
-  @doc """
-  Starts an application in synchronous phases.
-
-  This function is called after `start/2` finishes but before
-  `Application.start/2` returns. It will be called once for every start phase
-  defined in the application's (and any included applications') specification,
-  in the order they are listed in.
-  """
-  @callback start_phase(phase :: term, start_type, phase_args :: term) ::
-              :ok | {:error, reason :: term}
-
-  @doc """
-  Callback invoked after code upgrade, if the application environment
-  has changed.
-
-  `changed` is a keyword list of keys and their changed values in the
-  application environment. `new` is a keyword list with all new keys
-  and their values. `removed` is a list with all removed keys.
-  """
-  @callback config_change(changed, new, removed) :: :ok
-            when changed: keyword, new: keyword, removed: [atom]
-
-  @optional_callbacks start_phase: 3, prep_stop: 1, config_change: 3
-
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
@@ -373,49 +155,34 @@ defmodule Application do
         :ok
       end
 
-      defoverridable Application
+      defoverridable [stop: 1]
     end
   end
 
-  @application_keys [
-    :description,
-    :id,
-    :vsn,
-    :modules,
-    :maxP,
-    :maxT,
-    :registered,
-    :included_applications,
-    :applications,
-    :mod,
-    :start_phases
-  ]
-
-  application_key_specs = Enum.reduce(@application_keys, &{:|, [], [&1, &2]})
-
   @type app :: atom
   @type key :: atom
-  @type application_key :: unquote(application_key_specs)
   @type value :: term
   @type state :: term
-  @type start_type :: :normal | {:takeover, node} | {:failover, node}
-  @type restart_type :: :permanent | :transient | :temporary
+  @type start_type :: :permanent | :transient | :temporary
+
+  @application_keys [:description, :id, :vsn, :modules, :maxP, :maxT, :registered,
+                     :included_applications, :applications, :mod, :start_phases]
 
   @doc """
   Returns the spec for `app`.
 
   The following keys are returned:
 
-    * #{Enum.map_join(@application_keys, "\n  * ", &"`#{inspect(&1)}`")}
+    * #{Enum.map_join @application_keys, "\n  * ", &inspect/1}
 
   Note the environment is not returned as it can be accessed via
   `fetch_env/2`. Returns `nil` if the application is not loaded.
   """
-  @spec spec(app) :: [{application_key, value}] | nil
-  def spec(app) when is_atom(app) do
+  @spec spec(app) :: [{key, value}] | nil
+  def spec(app) do
     case :application.get_all_key(app) do
       {:ok, info} -> :lists.keydelete(:env, 1, info)
-      :undefined -> nil
+      :undefined  -> nil
     end
   end
 
@@ -426,8 +193,8 @@ defmodule Application do
   specification parameter does not exist, this function
   will raise. Returns `nil` if the application is not loaded.
   """
-  @spec spec(app, application_key) :: value | nil
-  def spec(app, key) when is_atom(app) and key in @application_keys do
+  @spec spec(app, key) :: value | nil
+  def spec(app, key) when key in @application_keys do
     case :application.get_key(app, key) do
       {:ok, value} -> value
       :undefined -> nil
@@ -453,171 +220,18 @@ defmodule Application do
   Returns all key-value pairs for `app`.
   """
   @spec get_all_env(app) :: [{key, value}]
-  def get_all_env(app) when is_atom(app) do
+  def get_all_env(app) do
     :application.get_all_env(app)
   end
 
-  @doc """
-  Reads the application environment at compilation time.
-
-  Similar to `get_env/3`, except it must be used to read values
-  at compile time. This allows Elixir to track when configuration
-  values change between compile time and runtime.
-
-  The first argument is the application name. The second argument
-  `key_or_path` is either an atom key or a path to traverse in
-  search of the configuration, starting with an atom key.
-
-  For example, imagine the following configuration:
-
-      config :my_app, :key, [foo: [bar: :baz]]
-
-  We can access it during compile time as:
-
-      Application.compile_env(:my_app, :key)
-      #=> [foo: [bar: :baz]]
-
-      Application.compile_env(:my_app, [:key, :foo])
-      #=> [bar: :baz]
-
-      Application.compile_env(:my_app, [:key, :foo, :bar])
-      #=> :baz
-
-  A default value can also be given as third argument. If
-  any of the keys in the path along the way is missing, the
-  default value is used:
-
-      Application.compile_env(:my_app, [:unknown, :foo, :bar], :default)
-      #=> :default
-
-      Application.compile_env(:my_app, [:key, :unknown, :bar], :default)
-      #=> :default
-
-      Application.compile_env(:my_app, [:key, :foo, :unknown], :default)
-      #=> :default
-
-  Giving a path is useful to let Elixir know that only certain paths
-  in a large configuration are compile time dependent.
-  """
-  # TODO: Warn if get_env/fetch_env/fetch_env! is used at compile time instead of compile_env
-  @doc since: "1.10.0"
-  @spec compile_env(app, key | list, value) :: value
-  defmacro compile_env(app, key_or_path, default \\ nil) when is_atom(app) do
-    if __CALLER__.function do
-      raise "Application.compile_env/3 cannot be called inside functions, only in the module body"
-    end
-
-    quote do
-      Application.__compile_env__(unquote(app), unquote(key_or_path), unquote(default), __ENV__)
-    end
-  end
-
-  @doc false
-  def __compile_env__(app, key_or_path, default, env) do
-    case fetch_compile_env(app, key_or_path, env) do
-      {:ok, value} -> value
-      :error -> default
-    end
-  end
-
-  @doc """
-  Reads the application environment at compilation time or raises.
-
-  This is the same as `compile_env/3` but it raises an
-  ArgumentError if the configuration is not available.
-  """
-  @doc since: "1.10.0"
-  @spec compile_env!(app, key | list) :: value
-  defmacro compile_env!(app, key_or_path) when is_atom(app) do
-    if __CALLER__.function do
-      raise "Application.compile_env!/2 cannot be called inside functions, only in the module body"
-    end
-
-    quote do
-      Application.__compile_env__!(unquote(app), unquote(key_or_path), __ENV__)
-    end
-  end
-
-  @doc false
-  def __compile_env__!(app, key_or_path, env) do
-    case fetch_compile_env(app, key_or_path, env) do
-      {:ok, value} ->
-        value
-
-      :error ->
-        raise ArgumentError,
-              "could not fetch application environment #{inspect(key_or_path)} for application " <>
-                "#{inspect(app)} #{fetch_env_failed_reason(app, key_or_path)}"
-    end
-  end
-
-  defp fetch_compile_env(app, key, env) when is_atom(key),
-    do: fetch_compile_env(app, key, [], env)
-
-  defp fetch_compile_env(app, [key | paths], env) when is_atom(key),
-    do: fetch_compile_env(app, key, paths, env)
-
-  defp fetch_compile_env(app, key, path, env) do
-    return = traverse_env(fetch_env(app, key), path)
-
-    for tracer <- env.tracers do
-      tracer.trace({:compile_env, app, [key | path], return}, env)
-    end
-
-    return
-  end
-
-  defp traverse_env(return, []), do: return
-  defp traverse_env(:error, _paths), do: :error
-  defp traverse_env({:ok, value}, [key | keys]), do: traverse_env(Access.fetch(value, key), keys)
-
   @doc """
   Returns the value for `key` in `app`'s environment.
 
   If the configuration parameter does not exist, the function returns the
   `default` value.
-
-  **Important:** if you are reading the application environment at compilation
-  time, for example, inside the module definition instead of inside of a
-  function, see `compile_env/3` instead.
-
-  **Important:** if you are writing a library to be used by other developers,
-  it is generally recommended to avoid the application environment, as the
-  application environment is effectively a global storage. For more information,
-  read our [library guidelines](library-guidelines.html).
-
-  ## Examples
-
-  `get_env/3` is commonly used to read the configuration of your OTP applications.
-  Since Mix configurations are commonly used to configure applications, we will use
-  this as a point of illustration.
-
-  Consider a new application `:my_app`. `:my_app` contains a database engine which
-  supports a pool of databases. The database engine needs to know the configuration for
-  each of those databases, and that configuration is supplied by key-value pairs in
-  environment of `:my_app`.
-
-      config :my_app, Databases.RepoOne,
-        # A database configuration
-        ip: "localhost",
-        port: 5433
-
-      config :my_app, Databases.RepoTwo,
-        # Another database configuration (for the same OTP app)
-        ip: "localhost",
-        port: 20717
-
-      config :my_app, my_app_databases: [Databases.RepoOne, Databases.RepoTwo]
-
-  Our database engine used by `:my_app` needs to know what databases exist, and
-  what the database configurations are. The database engine can make a call to
-  `get_env(:my_app, :my_app_databases)` to retrieve the list of databases (specified
-  by module names). Our database engine can then traverse each repository in the
-  list and then call `get_env(:my_app, Databases.RepoOne)` and so forth to retrieve
-  the configuration of each one.
   """
   @spec get_env(app, key, value) :: value
-  def get_env(app, key, default \\ nil) when is_atom(app) do
+  def get_env(app, key, default \\ nil) do
     :application.get_env(app, key, default)
   end
 
@@ -627,7 +241,7 @@ defmodule Application do
   If the configuration parameter does not exist, the function returns `:error`.
   """
   @spec fetch_env(app, key) :: {:ok, value} | :error
-  def fetch_env(app, key) when is_atom(app) do
+  def fetch_env(app, key) do
     case :application.get_env(app, key) do
       {:ok, value} -> {:ok, value}
       :undefined -> :error
@@ -638,35 +252,15 @@ defmodule Application do
   Returns the value for `key` in `app`'s environment.
 
   If the configuration parameter does not exist, raises `ArgumentError`.
-
-  **Important:** if you are reading the application environment at compilation
-  time, for example, inside the module definition instead of inside of a
-  function, see `compile_env!/2` instead.
   """
-  @spec fetch_env!(app, key) :: value
-  def fetch_env!(app, key) when is_atom(app) do
+  @spec fetch_env!(app, key) :: value | no_return
+  def fetch_env!(app, key) do
     case fetch_env(app, key) do
-      {:ok, value} ->
-        value
-
+      {:ok, value} -> value
       :error ->
         raise ArgumentError,
-              "could not fetch application environment #{inspect(key)} for application " <>
-                "#{inspect(app)} #{fetch_env_failed_reason(app, key)}"
-    end
-  end
-
-  defp fetch_env_failed_reason(app, key) do
-    vsn = :application.get_key(app, :vsn)
-
-    case vsn do
-      {:ok, _} ->
-        "because configuration at #{inspect(key)} was not set"
-
-      :undefined ->
-        "because the application was not loaded/started. If your application " <>
-          "depends on #{inspect(app)} at runtime, make sure to load/start it or " <>
-          "list it under :extra_applications in your mix.exs file"
+          "application #{inspect app} is not loaded, " <>
+          "or the configuration parameter #{inspect key} is not set"
     end
   end
 
@@ -675,65 +269,30 @@ defmodule Application do
 
   ## Options
 
-    * `:timeout` - the timeout for the change (defaults to `5_000` milliseconds)
+    * `:timeout`    - the timeout for the change (defaults to 5000ms)
     * `:persistent` - persists the given value on application load and reloads
 
   If `put_env/4` is called before the application is loaded, the application
   environment values specified in the `.app` file will override the ones
   previously set.
 
-  The `:persistent` option can be set to `true` when there is a need to guarantee
+  The persistent option can be set to `true` when there is a need to guarantee
   parameters set with this function will not be overridden by the ones defined
   in the application resource file on load. This means persistent values will
   stick after the application is loaded and also on application reload.
   """
-  @spec put_env(app, key, value, timeout: timeout, persistent: boolean) :: :ok
-  def put_env(app, key, value, opts \\ []) when is_atom(app) do
+  @spec put_env(app, key, value, [timeout: timeout, persistent: boolean]) :: :ok
+  def put_env(app, key, value, opts \\ []) do
     :application.set_env(app, key, value, opts)
   end
 
-  # TODO: Remove this once we support Erlang/OTP 22+ exclusively.
-  @compile {:no_warn_undefined, {:application, :set_env, 2}}
-
-  @doc """
-  Puts the environment for multiple apps at the same time.
-
-  The given config should not:
-
-    * have the same application listed more than once
-    * have the same key inside the same application listed more than once
-
-  If those conditions are not met, the behaviour is undefined
-  (on Erlang/OTP 21 and earlier) or will raise (on Erlang/OTP 22
-  and later).
-
-  It receives the same options as `put_env/4`. Returns `:ok`.
-  """
-  @doc since: "1.9.0"
-  @spec put_all_env([{app, [{key, value}]}], timeout: timeout, persistent: boolean) :: :ok
-  def put_all_env(config, opts \\ []) when is_list(config) and is_list(opts) do
-    # TODO: Remove function exported? check when we require Erlang/OTP 22+
-    if function_exported?(:application, :set_env, 2) do
-      :application.set_env(config, opts)
-    else
-      for app_keyword <- config,
-          {app, keyword} = app_keyword,
-          key_value <- keyword,
-          {key, value} = key_value do
-        :application.set_env(app, key, value, opts)
-      end
-
-      :ok
-    end
-  end
-
   @doc """
   Deletes the `key` from the given `app` environment.
 
-  It receives the same options as `put_env/4`. Returns `:ok`.
+  See `put_env/4` for a description of the options.
   """
-  @spec delete_env(app, key, timeout: timeout, persistent: boolean) :: :ok
-  def delete_env(app, key, opts \\ []) when is_atom(app) do
+  @spec delete_env(app, key, [timeout: timeout, persistent: boolean]) :: :ok
+  def delete_env(app, key, opts \\ []) do
     :application.unset_env(app, key, opts)
   end
 
@@ -747,27 +306,11 @@ defmodule Application do
       :ok = Application.ensure_started(:my_test_dep)
 
   """
-  @spec ensure_started(app, restart_type) :: :ok | {:error, term}
+  @spec ensure_started(app, start_type) :: :ok | {:error, term}
   def ensure_started(app, type \\ :temporary) when is_atom(app) do
     :application.ensure_started(app, type)
   end
 
-  @doc """
-  Ensures the given `app` is loaded.
-
-  Same as `load/2` but returns `:ok` if the application was already
-  loaded.
-  """
-  @doc since: "1.10.0"
-  @spec ensure_loaded(app) :: :ok | {:error, term}
-  def ensure_loaded(app) when is_atom(app) do
-    case :application.load(app) do
-      :ok -> :ok
-      {:error, {:already_loaded, ^app}} -> :ok
-      {:error, _} = error -> error
-    end
-  end
-
   @doc """
   Ensures the given `app` and its applications are started.
 
@@ -775,7 +318,7 @@ defmodule Application do
   `:applications` in the `.app` file in case they were not previously
   started.
   """
-  @spec ensure_all_started(app, restart_type) :: {:ok, [app]} | {:error, {app, term}}
+  @spec ensure_all_started(app, start_type) :: {:ok, [app]} | {:error, {app, term}}
   def ensure_all_started(app, type \\ :temporary) when is_atom(app) do
     :application.ensure_all_started(app, type)
   end
@@ -791,7 +334,7 @@ defmodule Application do
   started before this application is. If not, `{:error, {:not_started, app}}` is
   returned, where `app` is the name of the missing application.
 
-  In case you want to automatically load **and start** all of `app`'s dependencies,
+  In case you want to automatically  load **and start** all of `app`'s dependencies,
   see `ensure_all_started/2`.
 
   The `type` argument specifies the type of the application:
@@ -814,7 +357,7 @@ defmodule Application do
   Note also that the `:transient` type is of little practical use, since when a
   supervision tree terminates, the reason is set to `:shutdown`, not `:normal`.
   """
-  @spec start(app, restart_type) :: :ok | {:error, term}
+  @spec start(app, start_type) :: :ok | {:error, term}
   def start(app, type \\ :temporary) when is_atom(app) do
     :application.start(app, type)
   end
@@ -825,7 +368,7 @@ defmodule Application do
   When stopped, the application is still loaded.
   """
   @spec stop(app) :: :ok | {:error, term}
-  def stop(app) when is_atom(app) do
+  def stop(app) do
     :application.stop(app)
   end
 
@@ -876,50 +419,31 @@ defmodule Application do
       #=> "bar-123"
 
   For more information on code paths, check the `Code` module in
-  Elixir and also Erlang's [`:code` module](http://www.erlang.org/doc/man/code.html).
+  Elixir and also Erlang's `:code` module.
   """
-  @spec app_dir(app) :: String.t()
+  @spec app_dir(app) :: String.t
   def app_dir(app) when is_atom(app) do
     case :code.lib_dir(app) do
       lib when is_list(lib) -> IO.chardata_to_string(lib)
-      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect(app)}"
+      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect app}"
     end
   end
 
   @doc """
   Returns the given path inside `app_dir/1`.
-
-  If `path` is a string, then it will be used as the path inside `app_dir/1`. If
-  `path` is a list of strings, it will be joined (see `Path.join/1`) and the result
-  will be used as the path inside `app_dir/1`.
-
-  ## Examples
-
-      File.mkdir_p!("foo/ebin")
-      Code.prepend_path("foo/ebin")
-
-      Application.app_dir(:foo, "my_path")
-      #=> "foo/my_path"
-
-      Application.app_dir(:foo, ["my", "nested", "path"])
-      #=> "foo/my/nested/path"
-
   """
-  @spec app_dir(app, String.t() | [String.t()]) :: String.t()
-  def app_dir(app, path)
-
-  def app_dir(app, path) when is_atom(app) and is_binary(path) do
+  @spec app_dir(app, String.t | [String.t]) :: String.t
+  def app_dir(app, path) when is_binary(path) do
     Path.join(app_dir(app), path)
   end
-
-  def app_dir(app, path) when is_atom(app) and is_list(path) do
+  def app_dir(app, path) when is_list(path) do
     Path.join([app_dir(app) | path])
   end
 
   @doc """
   Returns a list with information about the applications which are currently running.
   """
-  @spec started_applications(timeout) :: [{app, description :: charlist(), vsn :: charlist()}]
+  @spec started_applications(timeout) :: [tuple]
   def started_applications(timeout \\ 5000) do
     :application.which_applications(timeout)
   end
@@ -927,9 +451,9 @@ defmodule Application do
   @doc """
   Returns a list with information about the applications which have been loaded.
   """
-  @spec loaded_applications :: [{app, description :: charlist(), vsn :: charlist()}]
+  @spec loaded_applications :: [tuple]
   def loaded_applications do
-    :application.loaded_applications()
+    :application.loaded_applications
   end
 
   @doc """
@@ -937,7 +461,7 @@ defmodule Application do
   `ensure_started/2`, `stop/1`, `load/1` and `unload/1`,
   returns a string.
   """
-  @spec format_error(any) :: String.t()
+  @spec format_error(any) :: String.t
   def format_error(reason) do
     try do
       do_format_error(reason)
@@ -956,8 +480,8 @@ defmodule Application do
 
   # {:error, reason} return value
   defp do_format_error({reason, {mod, :start, args}}) do
-    Exception.format_mfa(mod, :start, args) <>
-      " returned an error: " <> Exception.format_exit(reason)
+    Exception.format_mfa(mod, :start, args) <> " returned an error: " <>
+      Exception.format_exit(reason)
   end
 
   # error or exit(reason) call, use exit reason as reason.
@@ -967,7 +491,8 @@ defmodule Application do
 
   # bad return value
   defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do
-    Exception.format_mfa(mod, :start, args) <> " returned a bad value: " <> inspect(return)
+    Exception.format_mfa(mod, :start, args) <>
+      " returned a bad value: " <> inspect(return)
   end
 
   defp do_format_error({:already_started, app}) when is_atom(app) do

lib/elixir/lib/atom.ex

@@ -1,46 +1,8 @@
 defmodule Atom do
   @moduledoc """
-  Atoms are constants whose values are their own name.
-
-  They are often useful to enumerate over distinct values, such as:
-
-      iex> :apple
-      :apple
-      iex> :orange
-      :orange
-      iex> :watermelon
-      :watermelon
-
-  Atoms are equal if their names are equal.
-
-      iex> :apple == :apple
-      true
-      iex> :apple == :orange
-      false
-
-  Often they are used to express the state of an operation, by using
-  values such as `:ok` and `:error`.
-
-  The booleans `true` and `false` are also atoms:
-
-      iex> true == :true
-      true
-      iex> is_atom(false)
-      true
-      iex> is_boolean(:false)
-      true
-
-  Elixir allows you to skip the leading `:` for the atoms `false`, `true`,
-  and `nil`.
-
-  Atoms must be composed of Unicode characters such as letters, numbers,
-  underscore, and `@`. If the keyword has a character that does not
-  belong to the category above, such as spaces, you can wrap it in
-  quotes:
-
-      iex> :"this is an atom with spaces"
-      :"this is an atom with spaces"
+  Convenience functions for working with atoms.
 
+  See also `Kernel.is_atom/1`.
   """
 
   @doc """
@@ -54,7 +16,7 @@ defmodule Atom do
       "foo"
 
   """
-  @spec to_string(atom) :: String.t()
+  @spec to_string(atom) :: String.t
   def to_string(atom) do
     :erlang.atom_to_binary(atom, :utf8)
   end
@@ -75,8 +37,8 @@ defmodule Atom do
     :erlang.atom_to_list(atom)
   end
 
+  # TODO: Deprecate by v1.5
   @doc false
-  @deprecated "Use Atom.to_charlist/1 instead"
   @spec to_char_list(atom) :: charlist
   def to_char_list(atom), do: Atom.to_charlist(atom)
 end

lib/elixir/lib/behaviour.ex

@@ -1,19 +1,15 @@
 defmodule Behaviour do
   @moduledoc """
-  Mechanism for handling behaviours.
+  This module has been deprecated.
 
-  This module is deprecated. Instead of `defcallback/1` and
-  `defmacrocallback/1`, the `@callback` and `@macrocallback`
-  module attributes can be used (respectively). See the
-  documentation for `Module` for more information on these
-  attributes.
+  Instead of `defcallback/1` and `defmacrocallback/1`, the `@callback` and
+  `@macrocallback` module attributes can be used (respectively). See the
+  documentation for `Module` for more information on these attributes.
 
   Instead of `MyModule.__behaviour__(:callbacks)`,
   `MyModule.behaviour_info(:callbacks)` can be used.
   """
 
-  @moduledoc deprecated: "Use @callback and @macrocallback attributes instead"
-
   @doc """
   Defines a function callback according to the given type specification.
   """
@@ -25,10 +21,10 @@ defmodule Behaviour do
   Defines a macro callback according to the given type specification.
   """
   defmacro defmacrocallback(spec) do
-    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t())))
+    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t)))
   end
 
-  defp split_spec({:when, _, [{:"::", _, [spec, return]}, guard]}, _default) do
+  defp split_spec({:when, _, [{:::, _, [spec, return]}, guard]}, _default) do
     {spec, return, guard}
   end
 
@@ -36,7 +32,7 @@ defmodule Behaviour do
     {spec, default, guard}
   end
 
-  defp split_spec({:"::", _, [spec, return]}, _default) do
+  defp split_spec({:::, _, [spec, return]}, _default) do
     {spec, return, []}
   end
 
@@ -48,25 +44,21 @@ defmodule Behaviour do
     case Macro.decompose_call(spec) do
       {name, args} ->
         do_callback(kind, name, args, return, guards)
-
       _ ->
         raise ArgumentError, "invalid syntax in #{kind}callback #{Macro.to_string(spec)}"
     end
   end
 
   defp do_callback(kind, name, args, return, guards) do
-    fun = fn
-      {:"::", _, [left, right]} ->
+    :lists.foreach fn
+      {:::, _, [left, right]} ->
         ensure_not_default(left)
         ensure_not_default(right)
         left
-
       other ->
         ensure_not_default(other)
         other
-    end
-
-    :lists.foreach(fun, args)
+    end, args
 
     spec =
       quote do
@@ -74,8 +66,8 @@ defmodule Behaviour do
       end
 
     case kind do
-      :def -> quote(do: @callback(unquote(spec)))
-      :defmacro -> quote(do: @macrocallback(unquote(spec)))
+      :def -> quote(do: @callback unquote(spec))
+      :defmacro -> quote(do: @macrocallback unquote(spec))
     end
   end
 
@@ -90,9 +82,8 @@ defmodule Behaviour do
     quote do
       warning =
         "the Behaviour module is deprecated. Instead of using this module, " <>
-          "use the @callback and @macrocallback module attributes. See the " <>
-          "documentation for Module for more information on these attributes"
-
+        "use the @callback and @macrocallback module attributes. See the " <>
+        "documentation for Module for more information on these attributes"
       IO.warn(warning)
 
       @doc false
@@ -101,20 +92,14 @@ defmodule Behaviour do
       end
 
       def __behaviour__(:docs) do
-        {:docs_v1, _, :elixir, _, _, _, docs} = Code.fetch_docs(__MODULE__)
-
-        for {{kind, name, arity}, line, _, doc, _} <- docs, kind in [:callback, :macrocallback] do
+        for {tuple, line, kind, docs} <- Code.get_docs(__MODULE__, :callback_docs) do
           case kind do
-            :callback -> {{name, arity}, line, :def, __behaviour__doc_value(doc)}
-            :macrocallback -> {{name, arity}, line, :defmacro, __behaviour__doc_value(doc)}
+            :callback -> {tuple, line, :def, docs}
+            :macrocallback -> {tuple, line, :defmacro, docs}
           end
         end
       end
 
-      defp __behaviour__doc_value(:none), do: nil
-      defp __behaviour__doc_value(:hidden), do: false
-      defp __behaviour__doc_value(%{"en" => doc}), do: doc
-
       import unquote(__MODULE__)
     end
   end

lib/elixir/lib/bitwise.ex

@@ -1,17 +1,14 @@
 defmodule Bitwise do
   @moduledoc """
-  A set of functions that perform calculations on bits.
+  A set of macros that perform calculations on bits.
 
-  All bitwise functions work only on integers; otherwise an
-  `ArithmeticError` is raised.
-
-  The functions in this module come in two flavors: named or
+  The macros in this module come in two flavors: named or
   operators. For example:
 
       iex> use Bitwise
-      iex> bnot(1) # named
+      iex> bnot 1   # named
       -2
-      iex> 1 &&& 1 # operator
+      iex> 1 &&& 1  # operator
       1
 
   If you prefer to use only operators or skip them, you can
@@ -29,31 +26,25 @@ defmodule Bitwise do
   When invoked with no options, `use Bitwise` is equivalent
   to `import Bitwise`.
 
-  All bitwise functions can be used in guards:
+  All bitwise macros can be used in guards:
 
-      iex> odd? = fn
-      ...>   int when Bitwise.band(int, 1) == 1 -> true
-      ...>   _ -> false
-      ...> end
+      iex> use Bitwise
+      iex> odd? = fn int when band(int, 1) == 1 -> true; _ -> false end
       iex> odd?.(1)
       true
 
-  All functions in this module are inlined by the compiler.
   """
 
   @doc false
   defmacro __using__(options) do
-    except =
-      cond do
-        Keyword.get(options, :only_operators) ->
-          [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
-
-        Keyword.get(options, :skip_operators) ->
-          [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
-
-        true ->
-          []
-      end
+    except = cond do
+      Keyword.get(options, :only_operators) ->
+        [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
+      Keyword.get(options, :skip_operators) ->
+        [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
+      true ->
+        []
+    end
 
     quote do
       import Bitwise, except: unquote(except)
@@ -63,246 +54,160 @@ defmodule Bitwise do
   @doc """
   Calculates the bitwise NOT of its argument.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> bnot(2)
       -3
-
       iex> bnot(2) &&& 3
       1
 
   """
-  @doc guard: true
-  @spec bnot(integer) :: integer
-  def bnot(expr) do
-    :erlang.bnot(expr)
+  defmacro bnot(expr) do
+    quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
   Prefix (unary) operator; calculates the bitwise NOT of its argument.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> ~~~2
       -3
-
       iex> ~~~2 &&& 3
       1
 
   """
-  @doc guard: true
-  @spec ~~~integer :: integer
-  def ~~~expr do
-    :erlang.bnot(expr)
+  defmacro ~~~expr do
+    quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
   Calculates the bitwise AND of its arguments.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> band(9, 3)
       1
 
   """
-  @doc guard: true
-  @spec band(integer, integer) :: integer
-  def band(left, right) do
-    :erlang.band(left, right)
+  defmacro band(left, right) do
+    quote do: :erlang.band(unquote(left), unquote(right))
   end
 
   @doc """
   Infix operator; calculates the bitwise AND of its arguments.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> 9 &&& 3
       1
 
   """
-  @doc guard: true
-  @spec integer &&& integer :: integer
-  def left &&& right do
-    :erlang.band(left, right)
+  defmacro left &&& right do
+    quote do: :erlang.band(unquote(left), unquote(right))
   end
 
   @doc """
   Calculates the bitwise OR of its arguments.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> bor(9, 3)
       11
 
   """
-  @doc guard: true
-  @spec bor(integer, integer) :: integer
-  def bor(left, right) do
-    :erlang.bor(left, right)
+  defmacro bor(left, right) do
+    quote do: :erlang.bor(unquote(left), unquote(right))
   end
 
   @doc """
   Infix operator; calculates the bitwise OR of its arguments.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> 9 ||| 3
       11
 
   """
-  @doc guard: true
-  @spec integer ||| integer :: integer
-  def left ||| right do
-    :erlang.bor(left, right)
+  defmacro left ||| right do
+    quote do: :erlang.bor(unquote(left), unquote(right))
   end
 
   @doc """
   Calculates the bitwise XOR of its arguments.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> bxor(9, 3)
       10
 
   """
-  @doc guard: true
-  @spec bxor(integer, integer) :: integer
-  def bxor(left, right) do
-    :erlang.bxor(left, right)
+  defmacro bxor(left, right) do
+    quote do: :erlang.bxor(unquote(left), unquote(right))
   end
 
   @doc """
   Infix operator; calculates the bitwise XOR of its arguments.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> 9 ^^^ 3
       10
 
   """
-  @doc guard: true
-  @spec integer ^^^ integer :: integer
-  def left ^^^ right do
-    :erlang.bxor(left, right)
+  defmacro left ^^^ right do
+    quote do: :erlang.bxor(unquote(left), unquote(right))
   end
 
   @doc """
   Calculates the result of an arithmetic left bitshift.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> bsl(1, 2)
       4
-
       iex> bsl(1, -2)
       0
-
       iex> bsl(-1, 2)
       -4
-
       iex> bsl(-1, -2)
       -1
 
   """
-  @doc guard: true
-  @spec bsl(integer, integer) :: integer
-  def bsl(left, right) do
-    :erlang.bsl(left, right)
+  defmacro bsl(left, right) do
+    quote do: :erlang.bsl(unquote(left), unquote(right))
   end
 
   @doc """
   Infix operator; calculates the result of an arithmetic left bitshift.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> 1 <<< 2
       4
-
       iex> 1 <<< -2
       0
-
       iex> -1 <<< 2
       -4
-
       iex> -1 <<< -2
       -1
 
   """
-  @doc guard: true
-  @spec integer <<< integer :: integer
-  def left <<< right do
-    :erlang.bsl(left, right)
+  defmacro left <<< right do
+    quote do: :erlang.bsl(unquote(left), unquote(right))
   end
 
   @doc """
   Calculates the result of an arithmetic right bitshift.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> bsr(1, 2)
       0
-
       iex> bsr(1, -2)
       4
-
       iex> bsr(-1, 2)
       -1
-
       iex> bsr(-1, -2)
       -4
 
   """
-  @doc guard: true
-  @spec bsr(integer, integer) :: integer
-  def bsr(left, right) do
-    :erlang.bsr(left, right)
+  defmacro bsr(left, right) do
+    quote do: :erlang.bsr(unquote(left), unquote(right))
   end
 
   @doc """
   Infix operator; calculates the result of an arithmetic right bitshift.
 
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
       iex> 1 >>> 2
       0
-
       iex> 1 >>> -2
       4
-
       iex> -1 >>> 2
       -1
-
       iex> -1 >>> -2
       -4
 
   """
-  @doc guard: true
-  @spec integer >>> integer :: integer
-  def left >>> right do
-    :erlang.bsr(left, right)
+  defmacro left >>> right do
+    quote do: :erlang.bsr(unquote(left), unquote(right))
   end
 end

lib/elixir/lib/calendar/date.ex

@@ -1,758 +0,0 @@
-defmodule Date do
-  @moduledoc """
-  A Date struct and functions.
-
-  The Date struct contains the fields year, month, day and calendar.
-  New dates can be built with the `new/3` function or using the
-  `~D` (see `Kernel.sigil_D/2`) sigil:
-
-      iex> ~D[2000-01-01]
-      ~D[2000-01-01]
-
-  Both `new/3` and sigil return a struct where the date fields can
-  be accessed directly:
-
-      iex> date = ~D[2000-01-01]
-      iex> date.year
-      2000
-      iex> date.month
-      1
-
-  The functions on this module work with the `Date` struct as well
-  as any struct that contains the same fields as the `Date` struct,
-  such as `NaiveDateTime` and `DateTime`. Such functions expect
-  `t:Calendar.date/0` in their typespecs (instead of `t:t/0`).
-
-  Developers should avoid creating the Date structs directly
-  and instead rely on the functions provided by this module as well
-  as the ones in third-party calendar libraries.
-
-  ## Comparing dates
-
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
-  and based on the `Date` struct fields. For proper comparison between
-  dates, use the `compare/2` function.
-
-  ## Using epochs
-
-  The `add/2` and `diff/2` functions can be used for computing dates
-  or retrieving the number of days between instants. For example, if there
-  is an interest in computing the number of days from the Unix epoch
-  (1970-01-01):
-
-      iex> Date.diff(~D[2010-04-17], ~D[1970-01-01])
-      14716
-
-      iex> Date.add(~D[1970-01-01], 14716)
-      ~D[2010-04-17]
-
-  Those functions are optimized to deal with common epochs, such
-  as the Unix Epoch above or the Gregorian Epoch (0000-01-01).
-  """
-
-  @enforce_keys [:year, :month, :day]
-  defstruct [:year, :month, :day, calendar: Calendar.ISO]
-
-  @type t :: %__MODULE__{
-          year: Calendar.year(),
-          month: Calendar.month(),
-          day: Calendar.day(),
-          calendar: Calendar.calendar()
-        }
-
-  @doc """
-  Returns a range of dates.
-
-  A range of dates represents a discrete number of dates where
-  the first and last values are dates with matching calendars.
-
-  Ranges of dates can be either increasing (`first <= last`) or
-  decreasing (`first > last`). They are also always inclusive.
-
-  ## Examples
-
-      iex> Date.range(~D[1999-01-01], ~D[2000-01-01])
-      #DateRange<~D[1999-01-01], ~D[2000-01-01]>
-
-  A range of dates implements the `Enumerable` protocol, which means
-  functions in the `Enum` module can be used to work with
-  ranges:
-
-      iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01])
-      iex> Enum.count(range)
-      366
-      iex> Enum.member?(range, ~D[2001-02-01])
-      true
-      iex> Enum.reduce(range, 0, fn _date, acc -> acc - 1 end)
-      -366
-
-  """
-  @doc since: "1.5.0"
-  @spec range(Date.t(), Date.t()) :: Date.Range.t()
-  def range(%Date{calendar: calendar} = first, %Date{calendar: calendar} = last) do
-    {first_days, _} = to_iso_days(first)
-    {last_days, _} = to_iso_days(last)
-
-    %Date.Range{
-      first: first,
-      last: last,
-      first_in_iso_days: first_days,
-      last_in_iso_days: last_days
-    }
-  end
-
-  def range(%Date{}, %Date{}) do
-    raise ArgumentError, "both dates must have matching calendars"
-  end
-
-  @doc """
-  Returns the current date in UTC.
-
-  ## Examples
-
-      iex> date = Date.utc_today()
-      iex> date.year >= 2016
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec utc_today(Calendar.calendar()) :: t
-  def utc_today(calendar \\ Calendar.ISO)
-
-  def utc_today(Calendar.ISO) do
-    {:ok, {year, month, day}, _, _} = Calendar.ISO.from_unix(System.os_time(), :native)
-    %Date{year: year, month: month, day: day}
-  end
-
-  def utc_today(calendar) do
-    calendar
-    |> DateTime.utc_now()
-    |> DateTime.to_date()
-  end
-
-  @doc """
-  Returns `true` if the year in the given `date` is a leap year.
-
-  ## Examples
-
-      iex> Date.leap_year?(~D[2000-01-01])
-      true
-      iex> Date.leap_year?(~D[2001-01-01])
-      false
-      iex> Date.leap_year?(~D[2004-01-01])
-      true
-      iex> Date.leap_year?(~D[1900-01-01])
-      false
-      iex> Date.leap_year?(~N[2004-01-01 01:23:45])
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec leap_year?(Calendar.date()) :: boolean()
-  def leap_year?(date)
-
-  def leap_year?(%{calendar: calendar, year: year}) do
-    calendar.leap_year?(year)
-  end
-
-  @doc """
-  Returns the number of days in the given `date` month.
-
-  ## Examples
-
-      iex> Date.days_in_month(~D[1900-01-13])
-      31
-      iex> Date.days_in_month(~D[1900-02-09])
-      28
-      iex> Date.days_in_month(~N[2000-02-20 01:23:45])
-      29
-
-  """
-  @doc since: "1.4.0"
-  @spec days_in_month(Calendar.date()) :: Calendar.day()
-  def days_in_month(date)
-
-  def days_in_month(%{calendar: calendar, year: year, month: month}) do
-    calendar.days_in_month(year, month)
-  end
-
-  @doc """
-  Returns the number of months in the given `date` year.
-
-  ## Example
-
-      iex> Date.months_in_year(~D[1900-01-13])
-      12
-
-  """
-  @doc since: "1.7.0"
-  @spec months_in_year(Calendar.date()) :: Calendar.month()
-  def months_in_year(date)
-
-  def months_in_year(%{calendar: calendar, year: year}) do
-    calendar.months_in_year(year)
-  end
-
-  @doc """
-  Builds a new ISO date.
-
-  Expects all values to be integers. Returns `{:ok, date}` if each
-  entry fits its appropriate range, returns `{:error, reason}` otherwise.
-
-  ## Examples
-
-      iex> Date.new(2000, 1, 1)
-      {:ok, ~D[2000-01-01]}
-      iex> Date.new(2000, 13, 1)
-      {:error, :invalid_date}
-      iex> Date.new(2000, 2, 29)
-      {:ok, ~D[2000-02-29]}
-
-      iex> Date.new(2000, 2, 30)
-      {:error, :invalid_date}
-      iex> Date.new(2001, 2, 29)
-      {:error, :invalid_date}
-
-  """
-  @spec new(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def new(year, month, day, calendar \\ Calendar.ISO) do
-    if calendar.valid_date?(year, month, day) do
-      {:ok, %Date{year: year, month: month, day: day, calendar: calendar}}
-    else
-      {:error, :invalid_date}
-    end
-  end
-
-  @doc """
-  Converts the given date to a string according to its calendar.
-
-  ### Examples
-
-      iex> Date.to_string(~D[2000-02-28])
-      "2000-02-28"
-      iex> Date.to_string(~N[2000-02-28 01:23:45])
-      "2000-02-28"
-      iex> Date.to_string(~D[-0100-12-15])
-      "-0100-12-15"
-
-  """
-  @spec to_string(Calendar.date()) :: String.t()
-  def to_string(date)
-
-  def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.date_to_string(year, month, day)
-  end
-
-  @doc """
-  Parses the extended "Dates" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  The year parsed by this function is limited to four digits.
-
-  ## Examples
-
-      iex> Date.from_iso8601("2015-01-23")
-      {:ok, ~D[2015-01-23]}
-
-      iex> Date.from_iso8601("2015:01:23")
-      {:error, :invalid_format}
-
-      iex> Date.from_iso8601("2015-01-32")
-      {:error, :invalid_date}
-
-  """
-  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO) do
-    with {:ok, {year, month, day}} <- Calendar.ISO.parse_date(string) do
-      convert(%Date{year: year, month: month, day: day}, calendar)
-    end
-  end
-
-  @doc """
-  Parses the extended "Dates" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Raises if the format is invalid.
-
-  ## Examples
-
-      iex> Date.from_iso8601!("2015-01-23")
-      ~D[2015-01-23]
-      iex> Date.from_iso8601!("2015:01:23")
-      ** (ArgumentError) cannot parse "2015:01:23" as date, reason: :invalid_format
-
-  """
-  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
-  def from_iso8601!(string, calendar \\ Calendar.ISO) do
-    case from_iso8601(string, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError, "cannot parse #{inspect(string)} as date, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given `date` to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  By default, `Date.to_iso8601/2` returns dates formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
-
-  Only supports converting dates which are in the ISO calendar,
-  or other calendars in which the days also start at midnight.
-  Attempting to convert dates from other calendars will raise an `ArgumentError`.
-
-  ### Examples
-
-      iex> Date.to_iso8601(~D[2000-02-28])
-      "2000-02-28"
-
-      iex> Date.to_iso8601(~D[2000-02-28], :basic)
-      "20000228"
-
-      iex> Date.to_iso8601(~N[2000-02-28 00:00:00])
-      "2000-02-28"
-
-  """
-  @spec to_iso8601(Calendar.date(), :extended | :basic) :: String.t()
-  def to_iso8601(date, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = date, format) when format in [:basic, :extended] do
-    %{year: year, month: month, day: day} = date
-    Calendar.ISO.date_to_string(year, month, day, format)
-  end
-
-  def to_iso8601(%{calendar: _} = date, format) when format in [:basic, :extended] do
-    date
-    |> convert!(Calendar.ISO)
-    |> to_iso8601()
-  end
-
-  @doc """
-  Converts the given `date` to an Erlang date tuple.
-
-  Only supports converting dates which are in the ISO calendar,
-  or other calendars in which the days also start at midnight.
-  Attempting to convert dates from other calendars will raise.
-
-  ## Examples
-
-      iex> Date.to_erl(~D[2000-01-01])
-      {2000, 1, 1}
-
-      iex> Date.to_erl(~N[2000-01-01 00:00:00])
-      {2000, 1, 1}
-
-  """
-  @spec to_erl(Calendar.date()) :: :calendar.date()
-  def to_erl(date) do
-    %{year: year, month: month, day: day} = convert!(date, Calendar.ISO)
-    {year, month, day}
-  end
-
-  @doc """
-  Converts an Erlang date tuple to a `Date` struct.
-
-  Only supports converting dates which are in the ISO calendar,
-  or other calendars in which the days also start at midnight.
-  Attempting to convert dates from other calendars will return an error tuple.
-
-  ## Examples
-
-      iex> Date.from_erl({2000, 1, 1})
-      {:ok, ~D[2000-01-01]}
-      iex> Date.from_erl({2000, 13, 1})
-      {:error, :invalid_date}
-
-  """
-  @spec from_erl(:calendar.date(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_erl(tuple, calendar \\ Calendar.ISO)
-
-  def from_erl({year, month, day}, calendar) do
-    with {:ok, date} <- new(year, month, day, Calendar.ISO), do: convert(date, calendar)
-  end
-
-  @doc """
-  Converts an Erlang date tuple but raises for invalid dates.
-
-  ## Examples
-
-      iex> Date.from_erl!({2000, 1, 1})
-      ~D[2000-01-01]
-      iex> Date.from_erl!({2000, 13, 1})
-      ** (ArgumentError) cannot convert {2000, 13, 1} to date, reason: :invalid_date
-
-  """
-  @spec from_erl!(:calendar.date(), Calendar.calendar()) :: t
-  def from_erl!(tuple, calendar \\ Calendar.ISO) do
-    case from_erl(tuple, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to date, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Compares two date structs.
-
-  Returns `:gt` if first date is later than the second
-  and `:lt` for vice versa. If the two dates are equal
-  `:eq` is returned.
-
-  ## Examples
-
-      iex> Date.compare(~D[2016-04-16], ~D[2016-04-28])
-      :lt
-
-  This function can also be used to compare across more
-  complex calendar types by considering only the date fields:
-
-      iex> Date.compare(~D[2016-04-16], ~N[2016-04-28 01:23:45])
-      :lt
-      iex> Date.compare(~D[2016-04-16], ~N[2016-04-16 01:23:45])
-      :eq
-      iex> Date.compare(~N[2016-04-16 12:34:56], ~N[2016-04-16 01:23:45])
-      :eq
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.date(), Calendar.date()) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar} = date1, %{calendar: calendar} = date2) do
-    %{year: year1, month: month1, day: day1} = date1
-    %{year: year2, month: month2, day: day2} = date2
-
-    case {{year1, month1, day1}, {year2, month2, day2}} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  def compare(date1, date2) do
-    if Calendar.compatible_calendars?(date1.calendar, date2.calendar) do
-      case {to_iso_days(date1), to_iso_days(date2)} do
-        {first, second} when first > second -> :gt
-        {first, second} when first < second -> :lt
-        _ -> :eq
-      end
-    else
-      raise ArgumentError, """
-      cannot compare #{inspect(date1)} with #{inspect(date2)}.
-
-      This comparison would be ambiguous as their calendars have incompatible day rollover moments.
-      Specify an exact time of day (using DateTime) to resolve this ambiguity
-      """
-    end
-  end
-
-  @doc """
-  Converts the given `date` from its calendar to the given `calendar`.
-
-  Returns `{:ok, date}` if the calendars are compatible,
-  or `{:error, :incompatible_calendars}` if they are not.
-
-  See also `Calendar.compatible_calendars?/2`.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Date.convert(~D[2000-01-01], Calendar.Holocene)
-      {:ok, %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.date(), Calendar.calendar()) ::
-          {:ok, t} | {:error, :incompatible_calendars}
-  def convert(%{calendar: calendar, year: year, month: month, day: day}, calendar) do
-    {:ok, %Date{calendar: calendar, year: year, month: month, day: day}}
-  end
-
-  def convert(%{calendar: calendar} = date, target_calendar) do
-    if Calendar.compatible_calendars?(calendar, target_calendar) do
-      result_date =
-        date
-        |> to_iso_days()
-        |> from_iso_days(target_calendar)
-
-      {:ok, result_date}
-    else
-      {:error, :incompatible_calendars}
-    end
-  end
-
-  @doc """
-  Similar to `Date.convert/2`, but raises an `ArgumentError`
-  if the conversion between the two calendars is not possible.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Date.convert!(~D[2000-01-01], Calendar.Holocene)
-      %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.date(), Calendar.calendar()) :: t
-  def convert!(date, calendar) do
-    case convert(date, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(date)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Adds the number of days to the given `date`.
-
-  The days are counted as Gregorian days. The date is returned in the same
-  calendar as it was given in.
-
-  ## Examples
-
-      iex> Date.add(~D[2000-01-03], -2)
-      ~D[2000-01-01]
-      iex> Date.add(~D[2000-01-01], 2)
-      ~D[2000-01-03]
-      iex> Date.add(~N[2000-01-01 09:00:00], 2)
-      ~D[2000-01-03]
-      iex> Date.add(~D[-0010-01-01], -2)
-      ~D[-0011-12-30]
-
-  """
-  @doc since: "1.5.0"
-  @spec add(Calendar.date(), integer()) :: t
-  def add(%{calendar: Calendar.ISO} = date, days) do
-    %{year: year, month: month, day: day} = date
-
-    {year, month, day} =
-      Calendar.ISO.date_to_iso_days(year, month, day)
-      |> Kernel.+(days)
-      |> Calendar.ISO.date_from_iso_days()
-
-    %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
-  end
-
-  def add(%{calendar: calendar} = date, days) do
-    {base_days, fraction} = to_iso_days(date)
-    from_iso_days({base_days + days, fraction}, calendar)
-  end
-
-  @doc """
-  Calculates the difference between two dates, in a full number of days.
-
-  It returns the number of Gregorian days between the dates. Only `Date`
-  structs that follow the same or compatible calendars can be compared
-  this way. If two calendars are not compatible, it will raise.
-
-  ## Examples
-
-      iex> Date.diff(~D[2000-01-03], ~D[2000-01-01])
-      2
-      iex> Date.diff(~D[2000-01-01], ~D[2000-01-03])
-      -2
-      iex> Date.diff(~D[0000-01-02], ~D[-0001-12-30])
-      3
-      iex> Date.diff(~D[2000-01-01], ~N[2000-01-03 09:00:00])
-      -2
-
-  """
-  @doc since: "1.5.0"
-  @spec diff(Calendar.date(), Calendar.date()) :: integer
-  def diff(%{calendar: Calendar.ISO} = date1, %{calendar: Calendar.ISO} = date2) do
-    %{year: year1, month: month1, day: day1} = date1
-    %{year: year2, month: month2, day: day2} = date2
-
-    Calendar.ISO.date_to_iso_days(year1, month1, day1) -
-      Calendar.ISO.date_to_iso_days(year2, month2, day2)
-  end
-
-  def diff(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do
-    if Calendar.compatible_calendars?(calendar1, calendar2) do
-      {days1, _} = to_iso_days(date1)
-      {days2, _} = to_iso_days(date2)
-      days1 - days2
-    else
-      raise ArgumentError,
-            "cannot calculate the difference between #{inspect(date1)} and #{inspect(date2)} because their calendars are not compatible and thus the result would be ambiguous"
-    end
-  end
-
-  defp to_iso_days(%{calendar: Calendar.ISO, year: year, month: month, day: day}) do
-    {Calendar.ISO.date_to_iso_days(year, month, day), {0, 86_400_000_000}}
-  end
-
-  defp to_iso_days(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.naive_datetime_to_iso_days(year, month, day, 0, 0, 0, {0, 0})
-  end
-
-  defp from_iso_days({days, _}, Calendar.ISO) do
-    {year, month, day} = Calendar.ISO.date_from_iso_days(days)
-    %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
-  end
-
-  defp from_iso_days(iso_days, target_calendar) do
-    {year, month, day, _, _, _, _} = target_calendar.naive_datetime_from_iso_days(iso_days)
-    %Date{year: year, month: month, day: day, calendar: target_calendar}
-  end
-
-  @doc """
-  Calculates the day of the week of a given `date`.
-
-  Returns the day of the week as an integer. For the ISO 8601
-  calendar (the default), it is an integer from 1 to 7, where
-  1 is Monday and 7 is Sunday.
-
-  ## Examples
-
-      iex> Date.day_of_week(~D[2016-10-31])
-      1
-      iex> Date.day_of_week(~D[2016-11-01])
-      2
-      iex> Date.day_of_week(~N[2016-11-01 01:23:45])
-      2
-      iex> Date.day_of_week(~D[-0015-10-30])
-      3
-
-  """
-  @doc since: "1.4.0"
-  @spec day_of_week(Calendar.date()) :: Calendar.day()
-  def day_of_week(date)
-
-  def day_of_week(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.day_of_week(year, month, day)
-  end
-
-  @doc """
-  Calculates the day of the year of a given `date`.
-
-  Returns the day of the year as an integer. For the ISO 8601
-  calendar (the default), it is an integer from 1 to 366.
-
-  ## Examples
-
-      iex> Date.day_of_year(~D[2016-01-01])
-      1
-      iex> Date.day_of_year(~D[2016-11-01])
-      306
-      iex> Date.day_of_year(~D[-0015-10-30])
-      303
-      iex> Date.day_of_year(~D[2004-12-31])
-      366
-
-  """
-  @doc since: "1.8.0"
-  @spec day_of_year(Calendar.date()) :: Calendar.day()
-  def day_of_year(date)
-
-  def day_of_year(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.day_of_year(year, month, day)
-  end
-
-  @doc """
-  Calculates the quarter of the year of a given `date`.
-
-  Returns the day of the year as an integer. For the ISO 8601
-  calendar (the default), it is an integer from 1 to 4.
-
-  ## Examples
-
-      iex> Date.quarter_of_year(~D[2016-10-31])
-      4
-      iex> Date.quarter_of_year(~D[2016-01-01])
-      1
-      iex> Date.quarter_of_year(~N[2016-04-01 01:23:45])
-      2
-      iex> Date.quarter_of_year(~D[-0015-09-30])
-      3
-
-  """
-  @doc since: "1.8.0"
-  @spec quarter_of_year(Calendar.date()) :: non_neg_integer()
-  def quarter_of_year(date)
-
-  def quarter_of_year(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.quarter_of_year(year, month, day)
-  end
-
-  @doc """
-  Calculates the year-of-era and era for a given
-  calendar year.
-
-  Returns a tuple `{year, era}` representing the
-  year within the era and the era number.
-
-  ## Examples
-
-      iex> Date.year_of_era(~D[0001-01-01])
-      {1, 1}
-      iex> Date.year_of_era(~D[0000-12-31])
-      {1, 0}
-      iex> Date.year_of_era(~D[-0001-01-01])
-      {2, 0}
-
-  """
-  @doc since: "1.8.0"
-  @spec year_of_era(Calendar.date()) :: {Calendar.year(), non_neg_integer()}
-  def year_of_era(date)
-
-  def year_of_era(%{calendar: calendar, year: year}) do
-    calendar.year_of_era(year)
-  end
-
-  @doc """
-  Calculates the day-of-era and era for a given
-  calendar `date`.
-
-  Returns a tuple `{day, era}` representing the
-  day within the era and the era number.
-
-  ## Examples
-
-      iex> Date.day_of_era(~D[0001-01-01])
-      {1, 1}
-
-      iex> Date.day_of_era(~D[0000-12-31])
-      {1, 0}
-
-  """
-  @doc since: "1.8.0"
-  @spec day_of_era(Calendar.date()) :: {Calendar.day(), non_neg_integer()}
-  def day_of_era(date)
-
-  def day_of_era(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.day_of_era(year, month, day)
-  end
-
-  ## Helpers
-
-  defimpl String.Chars do
-    def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
-      calendar.date_to_string(year, month, day)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{calendar: calendar, year: year, month: month, day: day}, _) do
-      "~D[" <> calendar.date_to_string(year, month, day) <> suffix(calendar) <> "]"
-    end
-
-    defp suffix(Calendar.ISO), do: ""
-    defp suffix(calendar), do: " " <> inspect(calendar)
-  end
-end

lib/elixir/lib/calendar/date_range.ex

@@ -1,132 +0,0 @@
-defmodule Date.Range do
-  @moduledoc """
-  Returns an inclusive range between dates.
-
-  Ranges must be created with the `Date.range/2` function.
-
-  The following fields are public:
-
-    * `:first` - the initial date on the range
-    * `:last` - the last date on the range
-
-  The remaining fields are private and should not be accessed.
-  """
-
-  @type t :: %__MODULE__{
-          first: Date.t(),
-          last: Date.t(),
-          first_in_iso_days: iso_days(),
-          last_in_iso_days: iso_days()
-        }
-
-  @typep iso_days() :: Calendar.iso_days()
-
-  defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days]
-
-  defimpl Enumerable do
-    def member?(%{first: %{calendar: calendar}} = range, %Date{calendar: calendar} = date) do
-      %{
-        first: first,
-        last: last,
-        first_in_iso_days: first_in_iso_days,
-        last_in_iso_days: last_in_iso_days
-      } = range
-
-      %{year: first_year, month: first_month, day: first_day} = first
-      %{year: last_year, month: last_month, day: last_day} = last
-      %{year: year, month: month, day: day} = date
-      first = {first_year, first_month, first_day}
-      last = {last_year, last_month, last_day}
-      date = {year, month, day}
-
-      if first_in_iso_days <= last_in_iso_days do
-        {:ok, date >= first and date <= last}
-      else
-        {:ok, date >= last and date <= first}
-      end
-    end
-
-    def member?(_, _) do
-      {:ok, false}
-    end
-
-    def count(%{first_in_iso_days: first, last_in_iso_days: last}) do
-      {:ok, abs(first - last) + 1}
-    end
-
-    def slice(range) do
-      %{
-        first_in_iso_days: first,
-        last_in_iso_days: last,
-        first: %{calendar: calendar}
-      } = range
-
-      if first <= last do
-        {:ok, last - first + 1, &slice_asc(first + &1, &2, calendar)}
-      else
-        {:ok, first - last + 1, &slice_desc(first - &1, &2, calendar)}
-      end
-    end
-
-    defp slice_asc(current, 1, calendar), do: [date_from_iso_days(current, calendar)]
-
-    defp slice_asc(current, remaining, calendar) do
-      [date_from_iso_days(current, calendar) | slice_asc(current + 1, remaining - 1, calendar)]
-    end
-
-    defp slice_desc(current, 1, calendar), do: [date_from_iso_days(current, calendar)]
-
-    defp slice_desc(current, remaining, calendar) do
-      [date_from_iso_days(current, calendar) | slice_desc(current - 1, remaining - 1, calendar)]
-    end
-
-    def reduce(range, acc, fun) do
-      %{
-        first_in_iso_days: first_in_iso_days,
-        last_in_iso_days: last_in_iso_days,
-        first: %{calendar: calendar}
-      } = range
-
-      up? = first_in_iso_days <= last_in_iso_days
-      reduce(first_in_iso_days, last_in_iso_days, acc, fun, calendar, up?)
-    end
-
-    defp reduce(_x, _y, {:halt, acc}, _fun, _calendar, _up?) do
-      {:halted, acc}
-    end
-
-    defp reduce(x, y, {:suspend, acc}, fun, calendar, up?) do
-      {:suspended, acc, &reduce(x, y, &1, fun, calendar, up?)}
-    end
-
-    defp reduce(x, y, {:cont, acc}, fun, calendar, up? = true) when x <= y do
-      reduce(x + 1, y, fun.(date_from_iso_days(x, calendar), acc), fun, calendar, up?)
-    end
-
-    defp reduce(x, y, {:cont, acc}, fun, calendar, up? = false) when x >= y do
-      reduce(x - 1, y, fun.(date_from_iso_days(x, calendar), acc), fun, calendar, up?)
-    end
-
-    defp reduce(_, _, {:cont, acc}, _fun, _calendar, _up) do
-      {:done, acc}
-    end
-
-    defp date_from_iso_days(days, Calendar.ISO) do
-      {year, month, day} = Calendar.ISO.date_from_iso_days(days)
-      %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
-    end
-
-    defp date_from_iso_days(days, calendar) do
-      {year, month, day, _, _, _, _} =
-        calendar.naive_datetime_from_iso_days({days, {0, 86_400_000_000}})
-
-      %Date{year: year, month: month, day: day, calendar: calendar}
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%Date.Range{first: first, last: last}, _) do
-      "#DateRange<" <> inspect(first) <> ", " <> inspect(last) <> ">"
-    end
-  end
-end

lib/elixir/lib/calendar/naive_datetime.ex

@@ -1,985 +0,0 @@
-defmodule NaiveDateTime do
-  @moduledoc """
-  A NaiveDateTime struct (without a time zone) and functions.
-
-  The NaiveDateTime struct contains the fields year, month, day, hour,
-  minute, second, microsecond and calendar. New naive datetimes can be
-  built with the `new/2` and `new/8` functions or using the
-  `~N` (see `Kernel.sigil_N/2`) sigil:
-
-      iex> ~N[2000-01-01 23:00:07]
-      ~N[2000-01-01 23:00:07]
-
-  The date and time fields in the struct can be accessed directly:
-
-      iex> naive = ~N[2000-01-01 23:00:07]
-      iex> naive.year
-      2000
-      iex> naive.second
-      7
-
-  We call them "naive" because this datetime representation does not
-  have a time zone. This means the datetime may not actually exist in
-  certain areas in the world even though it is valid.
-
-  For example, when daylight saving changes are applied by a region,
-  the clock typically moves forward or backward by one hour. This means
-  certain datetimes never occur or may occur more than once. Since
-  `NaiveDateTime` is not validated against a time zone, such errors
-  would go unnoticed.
-
-  Developers should avoid creating the NaiveDateTime structs directly
-  and instead, rely on the functions provided by this module as well
-  as the ones in third-party calendar libraries.
-
-  ## Comparing naive date times
-
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
-  and based on the `NaiveDateTime` struct fields. For proper comparison
-  between naive datetimes, use the `compare/2` function.
-
-  ## Using epochs
-
-  The `add/3` and `diff/3` functions can be used for computing with
-  date times or retrieving the number of seconds between instants.
-  For example, if there is an interest in computing the number of
-  seconds from the Unix epoch (1970-01-01 00:00:00):
-
-      iex> NaiveDateTime.diff(~N[2010-04-17 14:00:00], ~N[1970-01-01 00:00:00])
-      1271512800
-
-      iex> NaiveDateTime.add(~N[1970-01-01 00:00:00], 1_271_512_800)
-      ~N[2010-04-17 14:00:00]
-
-  Those functions are optimized to deal with common epochs, such
-  as the Unix Epoch above or the Gregorian Epoch (0000-01-01 00:00:00).
-  """
-
-  @enforce_keys [:year, :month, :day, :hour, :minute, :second]
-  defstruct [
-    :year,
-    :month,
-    :day,
-    :hour,
-    :minute,
-    :second,
-    microsecond: {0, 0},
-    calendar: Calendar.ISO
-  ]
-
-  @type t :: %__MODULE__{
-          year: Calendar.year(),
-          month: Calendar.month(),
-          day: Calendar.day(),
-          calendar: Calendar.calendar(),
-          hour: Calendar.hour(),
-          minute: Calendar.minute(),
-          second: Calendar.second(),
-          microsecond: Calendar.microsecond()
-        }
-
-  @doc """
-  Returns the current naive datetime in UTC.
-
-  Prefer using `DateTime.utc_now/0` when possible as, opposite
-  to `NaiveDateTime`, it will keep the time zone information.
-
-  ## Examples
-
-      iex> naive_datetime = NaiveDateTime.utc_now()
-      iex> naive_datetime.year >= 2016
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec utc_now(Calendar.calendar()) :: t
-  def utc_now(calendar \\ Calendar.ISO)
-
-  def utc_now(Calendar.ISO) do
-    {:ok, {year, month, day}, {hour, minute, second}, microsecond} =
-      Calendar.ISO.from_unix(:os.system_time(), :native)
-
-    %NaiveDateTime{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: Calendar.ISO
-    }
-  end
-
-  def utc_now(calendar) do
-    calendar
-    |> DateTime.utc_now()
-    |> DateTime.to_naive()
-  end
-
-  @doc """
-  Returns the "local time" for the machine the Elixir program is running on.
-
-  WARNING: This function can cause insidious bugs. It depends on the time zone
-  configuration at run time. This can changed and be set to a time zone that has
-  daylight saving jumps (spring forward or fall back).
-
-  This function can be used to display what the time is right now for the time
-  zone configuration that the machine happens to have. An example would be a
-  desktop program displaying a clock to the user. For any other uses it is
-  probably a bad idea to use this function.
-
-  For most cases, use `DateTime.now/2` or `DateTime.utc_now/1` instead.
-
-  Does not include fractional seconds.
-
-  ## Examples
-
-      iex> naive_datetime = NaiveDateTime.local_now()
-      iex> naive_datetime.year >= 2019
-      true
-
-  """
-  @doc since: "1.10.0"
-  @spec local_now(Calendar.calendar()) :: t
-  def local_now(calendar \\ Calendar.ISO)
-
-  def local_now(Calendar.ISO) do
-    {{year, month, day}, {hour, minute, second}} = :erlang.localtime()
-    {:ok, ndt} = NaiveDateTime.new(year, month, day, hour, minute, second)
-    ndt
-  end
-
-  def local_now(calendar) do
-    naive_datetime = local_now()
-
-    case convert(naive_datetime, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, :incompatible_calendars} ->
-        raise ArgumentError,
-              ~s(cannot get "local now" in target calendar #{inspect(calendar)}, ) <>
-                "reason: cannot convert from Calendar.ISO to #{inspect(calendar)}."
-    end
-  end
-
-  @doc """
-  Builds a new ISO naive datetime.
-
-  Expects all values to be integers. Returns `{:ok, naive_datetime}`
-  if each entry fits its appropriate range, returns `{:error, reason}`
-  otherwise.
-
-  ## Examples
-
-      iex> NaiveDateTime.new(2000, 1, 1, 0, 0, 0)
-      {:ok, ~N[2000-01-01 00:00:00]}
-      iex> NaiveDateTime.new(2000, 13, 1, 0, 0, 0)
-      {:error, :invalid_date}
-      iex> NaiveDateTime.new(2000, 2, 29, 0, 0, 0)
-      {:ok, ~N[2000-02-29 00:00:00]}
-      iex> NaiveDateTime.new(2000, 2, 30, 0, 0, 0)
-      {:error, :invalid_date}
-      iex> NaiveDateTime.new(2001, 2, 29, 0, 0, 0)
-      {:error, :invalid_date}
-
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1})
-      {:ok, ~N[2000-01-01 23:59:59.0]}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 999_999)
-      {:ok, ~N[2000-01-01 23:59:59.999999]}
-      iex> NaiveDateTime.new(2000, 1, 1, 24, 59, 59, 999_999)
-      {:error, :invalid_time}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 60, 59, 999_999)
-      {:error, :invalid_time}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 60, 999_999)
-      {:error, :invalid_time}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 1_000_000)
-      {:error, :invalid_time}
-
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
-      {:ok, ~N[2000-01-01 23:59:59.0]}
-
-  """
-  @spec new(
-          Calendar.year(),
-          Calendar.month(),
-          Calendar.day(),
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond() | non_neg_integer,
-          Calendar.calendar()
-        ) :: {:ok, t} | {:error, atom}
-  def new(year, month, day, hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def new(year, month, day, hour, minute, second, microsecond, calendar)
-      when is_integer(microsecond) do
-    new(year, month, day, hour, minute, second, {microsecond, 6}, calendar)
-  end
-
-  def new(year, month, day, hour, minute, second, microsecond, calendar) do
-    cond do
-      not calendar.valid_date?(year, month, day) ->
-        {:error, :invalid_date}
-
-      not calendar.valid_time?(hour, minute, second, microsecond) ->
-        {:error, :invalid_time}
-
-      true ->
-        naive_datetime = %NaiveDateTime{
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        }
-
-        {:ok, naive_datetime}
-    end
-  end
-
-  @doc """
-  Builds a naive datetime from date and time structs.
-
-  ## Examples
-
-      iex> NaiveDateTime.new(~D[2010-01-13], ~T[23:00:07.005])
-      {:ok, ~N[2010-01-13 23:00:07.005]}
-
-  """
-  @spec new(Date.t(), Time.t()) :: {:ok, t}
-  def new(date, time)
-
-  def new(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time) do
-    %{year: year, month: month, day: day} = date
-    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
-
-    naive_datetime = %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-
-    {:ok, naive_datetime}
-  end
-
-  @doc """
-  Adds a specified amount of time to a `NaiveDateTime`.
-
-  Accepts an `amount_to_add` in any `unit` available from `t:System.time_unit/0`.
-  Negative values will move backwards in time.
-
-  ## Examples
-
-      # adds seconds by default
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2)
-      ~N[2014-10-02 00:29:12]
-
-      # accepts negative offsets
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], -2)
-      ~N[2014-10-02 00:29:08]
-
-      # can work with other units
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2_000, :millisecond)
-      ~N[2014-10-02 00:29:12]
-
-      # keeps the same precision
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10.021], 21, :second)
-      ~N[2014-10-02 00:29:31.021]
-
-      # changes below the precision will not be visible
-      iex> hidden = NaiveDateTime.add(~N[2014-10-02 00:29:10], 21, :millisecond)
-      iex> hidden.microsecond # ~N[2014-10-02 00:29:10]
-      {21000, 0}
-
-      # from Gregorian seconds
-      iex> NaiveDateTime.add(~N[0000-01-01 00:00:00], 63_579_428_950)
-      ~N[2014-10-02 00:29:10]
-
-  Passing a `DateTime` automatically converts it to `NaiveDateTime`,
-  discarding the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.add(dt, 21, :second)
-      ~N[2000-02-29 23:00:28]
-
-  """
-  @doc since: "1.4.0"
-  @spec add(Calendar.naive_datetime(), integer, System.time_unit()) :: t
-  def add(
-        %{microsecond: {_, precision}, calendar: calendar} = naive_datetime,
-        amount_to_add,
-        unit \\ :second
-      )
-      when is_integer(amount_to_add) do
-    ppd = System.convert_time_unit(86400, :second, unit)
-
-    naive_datetime
-    |> to_iso_days()
-    |> Calendar.ISO.add_day_fraction_to_iso_days(amount_to_add, ppd)
-    |> from_iso_days(calendar, precision)
-  end
-
-  @doc """
-  Subtracts `naive_datetime2` from `naive_datetime1`.
-
-  The answer can be returned in any `unit` available from `t:System.time_unit/0`.
-
-  This function returns the difference in seconds where seconds are measured
-  according to `Calendar.ISO`.
-
-  ## Examples
-
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10])
-      2
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10], :microsecond)
-      2_000_000
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021], :millisecond)
-      21
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[2014-10-02 00:29:12])
-      -2
-      iex> NaiveDateTime.diff(~N[-0001-10-02 00:29:10], ~N[-0001-10-02 00:29:12])
-      -2
-
-      # to Gregorian seconds
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[0000-01-01 00:00:00])
-      63579428950
-
-  """
-  @doc since: "1.4.0"
-  @spec diff(Calendar.naive_datetime(), Calendar.naive_datetime(), System.time_unit()) :: integer
-  def diff(
-        %{calendar: calendar1} = naive_datetime1,
-        %{calendar: calendar2} = naive_datetime2,
-        unit \\ :second
-      ) do
-    if not Calendar.compatible_calendars?(calendar1, calendar2) do
-      raise ArgumentError,
-            "cannot calculate the difference between #{inspect(naive_datetime1)} and " <>
-              "#{inspect(naive_datetime2)} because their calendars are not compatible " <>
-              "and thus the result would be ambiguous"
-    end
-
-    units1 = naive_datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)
-    units2 = naive_datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)
-    units1 - units2
-  end
-
-  @doc """
-  Returns the given naive datetime with the microsecond field truncated to the
-  given precision (`:microsecond`, `:millisecond` or `:second`).
-
-  The given naive datetime is returned unchanged if it already has lower precision
-  than the given precision.
-
-  ## Examples
-
-      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond)
-      ~N[2017-11-06 00:23:51.123456]
-
-      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond)
-      ~N[2017-11-06 00:23:51.123]
-
-      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second)
-      ~N[2017-11-06 00:23:51]
-
-  """
-  @doc since: "1.6.0"
-  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
-  def truncate(%NaiveDateTime{microsecond: microsecond} = naive_datetime, precision) do
-    %{naive_datetime | microsecond: Calendar.truncate(microsecond, precision)}
-  end
-
-  def truncate(
-        %{
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        },
-        precision
-      ) do
-    %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: Calendar.truncate(microsecond, precision)
-    }
-  end
-
-  @doc """
-  Converts a `NaiveDateTime` into a `Date`.
-
-  Because `Date` does not hold time information,
-  data will be lost during the conversion.
-
-  ## Examples
-
-      iex> NaiveDateTime.to_date(~N[2002-01-13 23:00:07])
-      ~D[2002-01-13]
-
-  """
-  @spec to_date(Calendar.naive_datetime()) :: Date.t()
-  def to_date(%{
-        year: year,
-        month: month,
-        day: day,
-        calendar: calendar,
-        hour: _,
-        minute: _,
-        second: _,
-        microsecond: _
-      }) do
-    %Date{year: year, month: month, day: day, calendar: calendar}
-  end
-
-  @doc """
-  Converts a `NaiveDateTime` into `Time`.
-
-  Because `Time` does not hold date information,
-  data will be lost during the conversion.
-
-  ## Examples
-
-      iex> NaiveDateTime.to_time(~N[2002-01-13 23:00:07])
-      ~T[23:00:07]
-
-  """
-  @spec to_time(Calendar.naive_datetime()) :: Time.t()
-  def to_time(%{
-        year: _,
-        month: _,
-        day: _,
-        calendar: calendar,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond
-      }) do
-    %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: calendar
-    }
-  end
-
-  @doc """
-  Converts the given naive datetime to a string according to its calendar.
-
-  ### Examples
-
-      iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13])
-      "2000-02-28 23:00:13"
-      iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13.001])
-      "2000-02-28 23:00:13.001"
-      iex> NaiveDateTime.to_string(~N[-0100-12-15 03:20:31])
-      "-0100-12-15 03:20:31"
-
-  This function can also be used to convert a DateTime to a string without
-  the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.to_string(dt)
-      "2000-02-29 23:00:07"
-
-  """
-  @spec to_string(Calendar.naive_datetime()) :: String.t()
-  def to_string(%{calendar: calendar} = naive_datetime) do
-    %{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = naive_datetime
-
-    calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-  end
-
-  @doc """
-  Parses the extended "Date and time of day" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Time zone offset may be included in the string but they will be
-  simply discarded as such information is not included in naive date
-  times.
-
-  As specified in the standard, the separator "T" may be omitted if
-  desired as there is no ambiguity within this function.
-
-  The year parsed by this function is limited to four digits and,
-  while ISO 8601 allows datetimes to specify 24:00:00 as the zero
-  hour of the next day, this notation is not supported by Elixir.
-  Note leap seconds are not supported by the built-in Calendar.ISO.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07")
-      {:ok, ~N[2015-01-23 23:50:07]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07")
-      {:ok, ~N[2015-01-23 23:50:07]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07Z")
-      {:ok, ~N[2015-01-23 23:50:07]}
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0")
-      {:ok, ~N[2015-01-23 23:50:07.0]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07,0123456")
-      {:ok, ~N[2015-01-23 23:50:07.012345]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0123456")
-      {:ok, ~N[2015-01-23 23:50:07.012345]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123Z")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23P23:50:07")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015:01:23 23-50-07")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07A")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:61")
-      {:error, :invalid_time}
-      iex> NaiveDateTime.from_iso8601("2015-01-32 23:50:07")
-      {:error, :invalid_date}
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+00:00")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-02:30")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-24:00")
-      {:error, :invalid_format}
-
-  """
-  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO) do
-    with {:ok, {year, month, day, hour, minute, second, microsecond}} <-
-           Calendar.ISO.parse_naive_datetime(string) do
-      convert(
-        %NaiveDateTime{
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        },
-        calendar
-      )
-    end
-  end
-
-  @doc """
-  Parses the extended "Date and time of day" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Raises if the format is invalid.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07.123Z")
-      ~N[2015-01-23 23:50:07.123]
-      iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07,123Z")
-      ~N[2015-01-23 23:50:07.123]
-      iex> NaiveDateTime.from_iso8601!("2015-01-23P23:50:07")
-      ** (ArgumentError) cannot parse "2015-01-23P23:50:07" as naive datetime, reason: :invalid_format
-
-  """
-  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
-  def from_iso8601!(string, calendar \\ Calendar.ISO) do
-    case from_iso8601(string, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot parse #{inspect(string)} as naive datetime, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given naive datetime to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  By default, `NaiveDateTime.to_iso8601/2` returns naive datetimes formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
-
-  Only supports converting naive datetimes which are in the ISO calendar,
-  attempting to convert naive datetimes from other calendars will raise.
-
-  ### Examples
-
-      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13])
-      "2000-02-28T23:00:13"
-
-      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001])
-      "2000-02-28T23:00:13.001"
-
-      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001], :basic)
-      "20000228T230013.001"
-
-  This function can also be used to convert a DateTime to ISO 8601 without
-  the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.to_iso8601(dt)
-      "2000-02-29T23:00:07"
-
-  """
-  @spec to_iso8601(Calendar.naive_datetime(), :basic | :extended) :: String.t()
-  def to_iso8601(naive_datetime, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = naive_datetime, format)
-      when format in [:basic, :extended] do
-    %{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = naive_datetime
-
-    Calendar.ISO.date_to_string(year, month, day, format) <>
-      "T" <> Calendar.ISO.time_to_string(hour, minute, second, microsecond, format)
-  end
-
-  def to_iso8601(%{calendar: _} = naive_datetime, format) when format in [:basic, :extended] do
-    naive_datetime
-    |> convert!(Calendar.ISO)
-    |> to_iso8601(format)
-  end
-
-  @doc """
-  Converts a `NaiveDateTime` struct to an Erlang datetime tuple.
-
-  Only supports converting naive datetimes which are in the ISO calendar,
-  attempting to convert naive datetimes from other calendars will raise.
-
-  WARNING: Loss of precision may occur, as Erlang time tuples only store
-  hour/minute/second.
-
-  ## Examples
-
-      iex> NaiveDateTime.to_erl(~N[2000-01-01 13:30:15])
-      {{2000, 1, 1}, {13, 30, 15}}
-
-  This function can also be used to convert a DateTime to an Erlang
-  datetime tuple without the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.to_erl(dt)
-      {{2000, 2, 29}, {23, 00, 07}}
-
-  """
-  @spec to_erl(Calendar.naive_datetime()) :: :calendar.datetime()
-  def to_erl(%{calendar: _} = naive_datetime) do
-    %{year: year, month: month, day: day, hour: hour, minute: minute, second: second} =
-      convert!(naive_datetime, Calendar.ISO)
-
-    {{year, month, day}, {hour, minute, second}}
-  end
-
-  @doc """
-  Converts an Erlang datetime tuple to a `NaiveDateTime` struct.
-
-  Attempting to convert an invalid ISO calendar date will produce an error tuple.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}})
-      {:ok, ~N[2000-01-01 13:30:15]}
-      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
-      {:ok, ~N[2000-01-01 13:30:15.005]}
-      iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
-      {:error, :invalid_date}
-      iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
-      {:error, :invalid_date}
-
-  """
-  @spec from_erl(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def from_erl(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def from_erl({{year, month, day}, {hour, minute, second}}, microsecond, calendar) do
-    with {:ok, iso_naive_dt} <- new(year, month, day, hour, minute, second, microsecond),
-         do: convert(iso_naive_dt, calendar)
-  end
-
-  @doc """
-  Converts an Erlang datetime tuple to a `NaiveDateTime` struct.
-
-  Raises if the datetime is invalid.
-  Attempting to convert an invalid ISO calendar date will produce an error tuple.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}})
-      ~N[2000-01-01 13:30:15]
-      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
-      ~N[2000-01-01 13:30:15.005]
-      iex> NaiveDateTime.from_erl!({{2000, 13, 1}, {13, 30, 15}})
-      ** (ArgumentError) cannot convert {{2000, 13, 1}, {13, 30, 15}} to naive datetime, reason: :invalid_date
-
-  """
-  @spec from_erl!(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) :: t
-  def from_erl!(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
-    case from_erl(tuple, microsecond, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to naive datetime, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Compares two `NaiveDateTime` structs.
-
-  Returns `:gt` if first is later than the second
-  and `:lt` for vice versa. If the two NaiveDateTime
-  are equal `:eq` is returned.
-
-  ## Examples
-
-      iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15], ~N[2016-04-28 16:19:25])
-      :lt
-      iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15.1], ~N[2016-04-16 13:30:15.01])
-      :gt
-
-  This function can also be used to compare a DateTime without
-  the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.compare(dt, ~N[2000-02-29 23:00:07])
-      :eq
-      iex> NaiveDateTime.compare(dt, ~N[2000-01-29 23:00:07])
-      :gt
-      iex> NaiveDateTime.compare(dt, ~N[2000-03-29 23:00:07])
-      :lt
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.naive_datetime(), Calendar.naive_datetime()) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar1} = naive_datetime1, %{calendar: calendar2} = naive_datetime2) do
-    if Calendar.compatible_calendars?(calendar1, calendar2) do
-      case {to_iso_days(naive_datetime1), to_iso_days(naive_datetime2)} do
-        {first, second} when first > second -> :gt
-        {first, second} when first < second -> :lt
-        _ -> :eq
-      end
-    else
-      raise ArgumentError, """
-      cannot compare #{inspect(naive_datetime1)} with #{inspect(naive_datetime2)}.
-
-      This comparison would be ambiguous as their calendars have incompatible day rollover moments.
-      Specify an exact time of day (using `DateTime`s) to resolve this ambiguity
-      """
-    end
-  end
-
-  @doc """
-  Converts the given `naive_datetime` from one calendar to another.
-
-  If it is not possible to convert unambiguously between the calendars
-  (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple
-  is returned.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> NaiveDateTime.convert(~N[2000-01-01 13:30:15], Calendar.Holocene)
-      {:ok, %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
-                           hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.naive_datetime(), Calendar.calendar()) ::
-          {:ok, t} | {:error, :incompatible_calendars}
-
-  # Keep it multiline for proper function clause errors.
-  def convert(
-        %{
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        },
-        calendar
-      ) do
-    naive_datetime = %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-
-    {:ok, naive_datetime}
-  end
-
-  def convert(%{calendar: ndt_calendar, microsecond: {_, precision}} = naive_datetime, calendar) do
-    if Calendar.compatible_calendars?(ndt_calendar, calendar) do
-      result_naive_datetime =
-        naive_datetime
-        |> to_iso_days
-        |> from_iso_days(calendar, precision)
-
-      {:ok, result_naive_datetime}
-    else
-      {:error, :incompatible_calendars}
-    end
-  end
-
-  @doc """
-  Converts the given `naive_datetime` from one calendar to another.
-
-  If it is not possible to convert unambiguously between the calendars
-  (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> NaiveDateTime.convert!(~N[2000-01-01 13:30:15], Calendar.Holocene)
-      %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
-                     hour: 13, minute: 30, second: 15, microsecond: {0, 0}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.naive_datetime(), Calendar.calendar()) :: t
-  def convert!(naive_datetime, calendar) do
-    case convert(naive_datetime, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, :incompatible_calendars} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(naive_datetime)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(naive_datetime.calendar)} and #{inspect(calendar)} " <>
-                "have different day rollover moments, making this conversion ambiguous"
-    end
-  end
-
-  ## Helpers
-
-  # Keep it multiline for proper function clause errors.
-  defp to_iso_days(%{
-         calendar: calendar,
-         year: year,
-         month: month,
-         day: day,
-         hour: hour,
-         minute: minute,
-         second: second,
-         microsecond: microsecond
-       }) do
-    calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
-  end
-
-  defp from_iso_days(iso_days, calendar, precision) do
-    {year, month, day, hour, minute, second, {microsecond, _}} =
-      calendar.naive_datetime_from_iso_days(iso_days)
-
-    %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: {microsecond, precision}
-    }
-  end
-
-  defimpl String.Chars do
-    def to_string(naive_datetime) do
-      %{
-        calendar: calendar,
-        year: year,
-        month: month,
-        day: day,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond
-      } = naive_datetime
-
-      calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(naive_datetime, _) do
-      %{
-        year: year,
-        month: month,
-        day: day,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: calendar
-      } = naive_datetime
-
-      formatted =
-        calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-
-      "~N[" <> formatted <> suffix(calendar) <> "]"
-    end
-
-    defp suffix(Calendar.ISO), do: ""
-    defp suffix(calendar), do: " " <> inspect(calendar)
-  end
-end

lib/elixir/lib/calendar/time.ex

@@ -1,694 +0,0 @@
-defmodule Time do
-  @moduledoc """
-  A Time struct and functions.
-
-  The Time struct contains the fields hour, minute, second and microseconds.
-  New times can be built with the `new/4` function or using the
-  `~T` (see `Kernel.sigil_T/2`) sigil:
-
-      iex> ~T[23:00:07.001]
-      ~T[23:00:07.001]
-
-  Both `new/4` and sigil return a struct where the time fields can
-  be accessed directly:
-
-      iex> time = ~T[23:00:07.001]
-      iex> time.hour
-      23
-      iex> time.microsecond
-      {1000, 3}
-
-  The functions on this module work with the `Time` struct as well
-  as any struct that contains the same fields as the `Time` struct,
-  such as `NaiveDateTime` and `DateTime`. Such functions expect
-  `t:Calendar.time/0` in their typespecs (instead of `t:t/0`).
-
-  Developers should avoid creating the Time structs directly
-  and instead rely on the functions provided by this module as well
-  as the ones in third-party calendar libraries.
-
-  ## Comparing times
-
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
-  and based on the `Time` struct fields. For proper comparison between
-  times, use the `compare/2` function.
-  """
-
-  @enforce_keys [:hour, :minute, :second]
-  defstruct [:hour, :minute, :second, microsecond: {0, 0}, calendar: Calendar.ISO]
-
-  @type t :: %__MODULE__{
-          hour: Calendar.hour(),
-          minute: Calendar.minute(),
-          second: Calendar.second(),
-          microsecond: Calendar.microsecond(),
-          calendar: Calendar.calendar()
-        }
-
-  @parts_per_day 86_400_000_000
-
-  @doc """
-  Returns the current time in UTC.
-
-  ## Examples
-
-      iex> time = Time.utc_now()
-      iex> time.hour >= 0
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec utc_now(Calendar.calendar()) :: t
-  def utc_now(calendar \\ Calendar.ISO) do
-    {:ok, _, time, microsecond} = Calendar.ISO.from_unix(:os.system_time(), :native)
-    {hour, minute, second} = time
-
-    iso_time = %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: Calendar.ISO
-    }
-
-    convert!(iso_time, calendar)
-  end
-
-  @doc """
-  Builds a new time.
-
-  Expects all values to be integers. Returns `{:ok, time}` if each
-  entry fits its appropriate range, returns `{:error, reason}` otherwise.
-
-  Microseconds can also be given with a precision, which must be an
-  integer between 0 and 6.
-
-  The built-in calendar does not support leap seconds.
-
-  ## Examples
-
-      iex> Time.new(0, 0, 0, 0)
-      {:ok, ~T[00:00:00.000000]}
-      iex> Time.new(23, 59, 59, 999_999)
-      {:ok, ~T[23:59:59.999999]}
-
-      iex> Time.new(24, 59, 59, 999_999)
-      {:error, :invalid_time}
-      iex> Time.new(23, 60, 59, 999_999)
-      {:error, :invalid_time}
-      iex> Time.new(23, 59, 60, 999_999)
-      {:error, :invalid_time}
-      iex> Time.new(23, 59, 59, 1_000_000)
-      {:error, :invalid_time}
-
-      # Invalid precision
-      Time.new(23, 59, 59, {999_999, 10})
-      {:error, :invalid_time}
-
-  """
-  @spec new(
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond() | non_neg_integer,
-          Calendar.calendar()
-        ) :: {:ok, t} | {:error, atom}
-  def new(hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def new(hour, minute, second, microsecond, calendar) when is_integer(microsecond) do
-    new(hour, minute, second, {microsecond, 6}, calendar)
-  end
-
-  def new(hour, minute, second, {microsecond, precision}, calendar)
-      when is_integer(hour) and is_integer(minute) and is_integer(second) and
-             is_integer(microsecond) and is_integer(precision) do
-    case calendar.valid_time?(hour, minute, second, {microsecond, precision}) do
-      true ->
-        time = %Time{
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: {microsecond, precision},
-          calendar: calendar
-        }
-
-        {:ok, time}
-
-      false ->
-        {:error, :invalid_time}
-    end
-  end
-
-  @doc """
-  Converts the given `time` to a string.
-
-  ### Examples
-
-      iex> Time.to_string(~T[23:00:00])
-      "23:00:00"
-      iex> Time.to_string(~T[23:00:00.001])
-      "23:00:00.001"
-      iex> Time.to_string(~T[23:00:00.123456])
-      "23:00:00.123456"
-
-      iex> Time.to_string(~N[2015-01-01 23:00:00.001])
-      "23:00:00.001"
-      iex> Time.to_string(~N[2015-01-01 23:00:00.123456])
-      "23:00:00.123456"
-
-  """
-  @spec to_string(Calendar.time()) :: String.t()
-  def to_string(time)
-
-  def to_string(%{
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: calendar
-      }) do
-    calendar.time_to_string(hour, minute, second, microsecond)
-  end
-
-  @doc """
-  Parses the extended "Local time" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Time zone offset may be included in the string but they will be
-  simply discarded as such information is not included in times.
-
-  As specified in the standard, the separator "T" may be omitted if
-  desired as there is no ambiguity within this function.
-
-  Time representations with reduced accuracy are not supported.
-
-  Note that while ISO 8601 allows times to specify 24:00:00 as the
-  zero hour of the next day, this notation is not supported by Elixir.
-  Leap seconds are not supported as well by the built-in Calendar.ISO.
-
-  ## Examples
-
-      iex> Time.from_iso8601("23:50:07")
-      {:ok, ~T[23:50:07]}
-      iex> Time.from_iso8601("23:50:07Z")
-      {:ok, ~T[23:50:07]}
-      iex> Time.from_iso8601("T23:50:07Z")
-      {:ok, ~T[23:50:07]}
-
-      iex> Time.from_iso8601("23:50:07,0123456")
-      {:ok, ~T[23:50:07.012345]}
-      iex> Time.from_iso8601("23:50:07.0123456")
-      {:ok, ~T[23:50:07.012345]}
-      iex> Time.from_iso8601("23:50:07.123Z")
-      {:ok, ~T[23:50:07.123]}
-
-      iex> Time.from_iso8601("2015:01:23 23-50-07")
-      {:error, :invalid_format}
-      iex> Time.from_iso8601("23:50:07A")
-      {:error, :invalid_format}
-      iex> Time.from_iso8601("23:50:07.")
-      {:error, :invalid_format}
-      iex> Time.from_iso8601("23:50:61")
-      {:error, :invalid_time}
-
-  """
-  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO) do
-    with {:ok, {hour, minute, second, microsecond}} <- Calendar.ISO.parse_time(string) do
-      convert(
-        %Time{hour: hour, minute: minute, second: second, microsecond: microsecond},
-        calendar
-      )
-    end
-  end
-
-  @doc """
-  Parses the extended "Local time" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Raises if the format is invalid.
-
-  ## Examples
-
-      iex> Time.from_iso8601!("23:50:07,123Z")
-      ~T[23:50:07.123]
-      iex> Time.from_iso8601!("23:50:07.123Z")
-      ~T[23:50:07.123]
-      iex> Time.from_iso8601!("2015:01:23 23-50-07")
-      ** (ArgumentError) cannot parse "2015:01:23 23-50-07" as time, reason: :invalid_format
-
-  """
-  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
-  def from_iso8601!(string, calendar \\ Calendar.ISO) do
-    case from_iso8601(string, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError, "cannot parse #{inspect(string)} as time, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given time to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  By default, `Time.to_iso8601/2` returns times formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through
-  passing the `:basic` option.
-
-  ### Examples
-
-      iex> Time.to_iso8601(~T[23:00:13])
-      "23:00:13"
-
-      iex> Time.to_iso8601(~T[23:00:13.001])
-      "23:00:13.001"
-
-      iex> Time.to_iso8601(~T[23:00:13.001], :basic)
-      "230013.001"
-
-      iex> Time.to_iso8601(~N[2010-04-17 23:00:13])
-      "23:00:13"
-
-  """
-  @spec to_iso8601(Calendar.time(), :extended | :basic) :: String.t()
-  def to_iso8601(time, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = time, format) when format in [:extended, :basic] do
-    %{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = time
-
-    Calendar.ISO.time_to_string(hour, minute, second, microsecond, format)
-  end
-
-  def to_iso8601(%{calendar: _} = time, format) when format in [:extended, :basic] do
-    time
-    |> convert!(Calendar.ISO)
-    |> to_iso8601(format)
-  end
-
-  @doc """
-  Converts given `time` to an Erlang time tuple.
-
-  WARNING: Loss of precision may occur, as Erlang time tuples
-  only contain hours/minutes/seconds.
-
-  ## Examples
-
-      iex> Time.to_erl(~T[23:30:15.999])
-      {23, 30, 15}
-
-      iex> Time.to_erl(~N[2010-04-17 23:30:15.999])
-      {23, 30, 15}
-
-  """
-  @spec to_erl(Calendar.time()) :: :calendar.time()
-  def to_erl(time) do
-    %{hour: hour, minute: minute, second: second} = convert!(time, Calendar.ISO)
-    {hour, minute, second}
-  end
-
-  @doc """
-  Converts an Erlang time tuple to a `Time` struct.
-
-  ## Examples
-
-      iex> Time.from_erl({23, 30, 15}, {5000, 3})
-      {:ok, ~T[23:30:15.005]}
-      iex> Time.from_erl({24, 30, 15})
-      {:error, :invalid_time}
-
-  """
-  @spec from_erl(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def from_erl(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def from_erl({hour, minute, second}, microsecond, calendar) do
-    with {:ok, time} <- new(hour, minute, second, microsecond, Calendar.ISO),
-         do: convert(time, calendar)
-  end
-
-  @doc """
-  Converts an Erlang time tuple to a `Time` struct.
-
-  ## Examples
-
-      iex> Time.from_erl!({23, 30, 15})
-      ~T[23:30:15]
-      iex> Time.from_erl!({23, 30, 15}, {5000, 3})
-      ~T[23:30:15.005]
-      iex> Time.from_erl!({24, 30, 15})
-      ** (ArgumentError) cannot convert {24, 30, 15} to time, reason: :invalid_time
-
-  """
-  @spec from_erl!(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) :: t
-  def from_erl!(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
-    case from_erl(tuple, microsecond, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to time, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Adds the `number` of `unit`s to the given `time`.
-
-  This function accepts the `number` measured according to `Calendar.ISO`.
-  The time is returned in the same calendar as it was given in.
-
-  Note the result value represents the time of day, meaning that it is cyclic,
-  for instance, it will never go over 24 hours for the ISO calendar.
-
-  ## Examples
-
-      iex> Time.add(~T[10:00:00], 27000)
-      ~T[17:30:00.000000]
-      iex> Time.add(~T[11:00:00.005], 2400)
-      ~T[11:40:00.005000]
-      iex> Time.add(~T[00:00:00], 86_399_999, :millisecond)
-      ~T[23:59:59.999000]
-      iex> Time.add(~T[17:10:05], 86400)
-      ~T[17:10:05.000000]
-      iex> Time.add(~T[23:00:00], -60)
-      ~T[22:59:00.000000]
-
-  """
-  @doc since: "1.6.0"
-  @spec add(Calendar.time(), integer, System.time_unit()) :: t
-  def add(%{calendar: calendar} = time, number, unit \\ :second) when is_integer(number) do
-    number = System.convert_time_unit(number, unit, :microsecond)
-    total = time_to_microseconds(time) + number
-    parts = Integer.mod(total, @parts_per_day)
-    {hour, minute, second, microsecond} = calendar.time_from_day_fraction({parts, @parts_per_day})
-
-    %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: calendar
-    }
-  end
-
-  defp time_to_microseconds(%{
-         calendar: Calendar.ISO,
-         hour: 0,
-         minute: 0,
-         second: 0,
-         microsecond: {0, _}
-       }) do
-    0
-  end
-
-  defp time_to_microseconds(time) do
-    iso_days = {0, to_day_fraction(time)}
-    Calendar.ISO.iso_days_to_unit(iso_days, :microsecond)
-  end
-
-  @doc """
-  Compares two time structs.
-
-  Returns `:gt` if first time is later than the second
-  and `:lt` for vice versa. If the two times are equal
-  `:eq` is returned.
-
-  ## Examples
-
-      iex> Time.compare(~T[16:04:16], ~T[16:04:28])
-      :lt
-      iex> Time.compare(~T[16:04:16], ~T[16:04:16])
-      :eq
-      iex> Time.compare(~T[16:04:16.01], ~T[16:04:16.001])
-      :gt
-
-  This function can also be used to compare across more
-  complex calendar types by considering only the time fields:
-
-      iex> Time.compare(~N[1900-01-01 16:04:16], ~N[2015-01-01 16:04:16])
-      :eq
-      iex> Time.compare(~N[2015-01-01 16:04:16], ~N[2015-01-01 16:04:28])
-      :lt
-      iex> Time.compare(~N[2015-01-01 16:04:16.01], ~N[2000-01-01 16:04:16.001])
-      :gt
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.time(), Calendar.time()) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar} = time1, %{calendar: calendar} = time2) do
-    %{hour: hour1, minute: minute1, second: second1, microsecond: {microsecond1, _}} = time1
-    %{hour: hour2, minute: minute2, second: second2, microsecond: {microsecond2, _}} = time2
-
-    case {{hour1, minute1, second1, microsecond1}, {hour2, minute2, second2, microsecond2}} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  def compare(time1, time2) do
-    {parts1, ppd1} = to_day_fraction(time1)
-    {parts2, ppd2} = to_day_fraction(time2)
-
-    case {parts1 * ppd2, parts2 * ppd1} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  @doc """
-  Converts given `time` to a different calendar.
-
-  Returns `{:ok, time}` if the conversion was successful,
-  or `{:error, reason}` if it was not, for some reason.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Time.convert(~T[13:30:15], Calendar.Holocene)
-      {:ok, %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.time(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-
-  # Keep it multiline for proper function clause errors.
-  def convert(
-        %{
-          calendar: calendar,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        },
-        calendar
-      ) do
-    time = %Time{
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-
-    {:ok, time}
-  end
-
-  def convert(%{microsecond: {_, precision}} = time, calendar) do
-    {hour, minute, second, {microsecond, _}} =
-      time
-      |> to_day_fraction()
-      |> calendar.time_from_day_fraction()
-
-    time = %Time{
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: {microsecond, precision}
-    }
-
-    {:ok, time}
-  end
-
-  @doc """
-  Similar to `Time.convert/2`, but raises an `ArgumentError`
-  if the conversion between the two calendars is not possible.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Time.convert!(~T[13:30:15], Calendar.Holocene)
-      %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.time(), Calendar.calendar()) :: t
-  def convert!(time, calendar) do
-    case convert(time, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(time)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Returns the difference between two times, considering only the hour, minute,
-  second and microsecond.
-
-  As with the `compare/2` function both `Time` structs and other structures
-  containing time can be used. If for instance a `NaiveDateTime` or `DateTime`
-  is passed, only the hour, month, second, and microsecond is considered. Any
-  additional information about a date or time zone is ignored when calculating
-  the difference.
-
-  The answer can be returned in any `unit` available from
-  `t:System.time_unit/0`. If the first unit is smaller than
-  the second, a negative number is returned.
-
-  This function returns the difference in seconds where seconds
-  are measured according to `Calendar.ISO`.
-
-  ## Examples
-
-      iex> Time.diff(~T[00:29:12], ~T[00:29:10])
-      2
-
-      # When passing a `NaiveDateTime` the date part is ignored.
-      iex> Time.diff(~N[2017-01-01 00:29:12], ~T[00:29:10])
-      2
-
-      # Two `NaiveDateTime` structs could have big differences in the date
-      # but only the time part is considered.
-      iex> Time.diff(~N[2017-01-01 00:29:12], ~N[1900-02-03 00:29:10])
-      2
-
-      iex> Time.diff(~T[00:29:12], ~T[00:29:10], :microsecond)
-      2_000_000
-      iex> Time.diff(~T[00:29:10], ~T[00:29:12], :microsecond)
-      -2_000_000
-
-  """
-  @doc since: "1.5.0"
-  @spec diff(Calendar.time(), Calendar.time(), System.time_unit()) :: integer
-  def diff(time1, time2, unit \\ :second)
-
-  def diff(
-        %{
-          calendar: Calendar.ISO,
-          hour: hour1,
-          minute: minute1,
-          second: second1,
-          microsecond: {microsecond1, @parts_per_day}
-        },
-        %{
-          calendar: Calendar.ISO,
-          hour: hour2,
-          minute: minute2,
-          second: second2,
-          microsecond: {microsecond2, @parts_per_day}
-        },
-        unit
-      ) do
-    total =
-      (hour1 - hour2) * 3_600_000_000 + (minute1 - minute2) * 60_000_000 +
-        (second1 - second2) * 1_000_000 + (microsecond1 - microsecond2)
-
-    System.convert_time_unit(total, :microsecond, unit)
-  end
-
-  def diff(time1, time2, unit) do
-    fraction1 = to_day_fraction(time1)
-    fraction2 = to_day_fraction(time2)
-
-    Calendar.ISO.iso_days_to_unit({0, fraction1}, unit) -
-      Calendar.ISO.iso_days_to_unit({0, fraction2}, unit)
-  end
-
-  @doc """
-  Returns the given time with the microsecond field truncated to the given
-  precision (`:microsecond`, `millisecond` or `:second`).
-
-  The given time is returned unchanged if it already has lower precision than
-  the given precision.
-
-  ## Examples
-
-      iex> Time.truncate(~T[01:01:01.123456], :microsecond)
-      ~T[01:01:01.123456]
-
-      iex> Time.truncate(~T[01:01:01.123456], :millisecond)
-      ~T[01:01:01.123]
-
-      iex> Time.truncate(~T[01:01:01.123456], :second)
-      ~T[01:01:01]
-
-  """
-  @doc since: "1.6.0"
-  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
-  def truncate(%Time{microsecond: microsecond} = time, precision) do
-    %{time | microsecond: Calendar.truncate(microsecond, precision)}
-  end
-
-  ## Helpers
-
-  defp to_day_fraction(%{
-         hour: hour,
-         minute: minute,
-         second: second,
-         microsecond: {_, _} = microsecond,
-         calendar: calendar
-       }) do
-    calendar.time_to_day_fraction(hour, minute, second, microsecond)
-  end
-
-  defimpl String.Chars do
-    def to_string(time) do
-      %{
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: calendar
-      } = time
-
-      calendar.time_to_string(hour, minute, second, microsecond)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(time, _) do
-      %{
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: calendar
-      } = time
-
-      "~T[" <>
-        calendar.time_to_string(hour, minute, second, microsecond) <> suffix(calendar) <> "]"
-    end
-
-    defp suffix(Calendar.ISO), do: ""
-    defp suffix(calendar), do: " " <> inspect(calendar)
-  end
-end

lib/elixir/lib/calendar/time_zone_database.ex

@@ -1,96 +0,0 @@
-defmodule Calendar.TimeZoneDatabase do
-  @moduledoc """
-  This module defines a behaviour for providing time zone data.
-
-  IANA provides time zone data that includes data about different
-  UTC offsets and standard offsets for time zones.
-  """
-
-  @typedoc """
-  A period where a certain combination of UTC offset, standard offset and zone
-  abbreviation is in effect.
-
-  For instance one period could be the summer of 2018 in "Europe/London" where summer time /
-  daylight saving time is in effect and lasts from spring to autumn. At autumn the `std_offset`
-  changes along with the `zone_abbr` so a different period is needed during winter.
-  """
-  @type time_zone_period :: %{
-          optional(any) => any,
-          utc_offset: Calendar.utc_offset(),
-          std_offset: Calendar.std_offset(),
-          zone_abbr: Calendar.zone_abbr()
-        }
-
-  @typedoc """
-  Limit for when a certain time zone period begins or ends.
-
-  A beginning is inclusive. An ending is exclusive. Eg. if a period is from
-  2015-03-29 01:00:00 and until 2015-10-25 01:00:00, the period includes and
-  begins from the beginning of 2015-03-29 01:00:00 and lasts until just before
-  2015-10-25 01:00:00.
-
-  A beginning or end for certain periods are infinite. For instance the latest
-  period for time zones without DST or plans to change. However for the purpose
-  of this behaviour they are only used for gaps in wall time where the needed
-  period limits are at a certain time.
-  """
-  @type time_zone_period_limit :: Calendar.naive_datetime()
-
-  @doc """
-  Time zone period for a point in time in UTC for a specific time zone.
-
-  Takes a time zone name and a point in time for UTC and returns a
-  `time_zone_period` for that point in time.
-  """
-  @doc since: "1.8.0"
-  @callback time_zone_period_from_utc_iso_days(Calendar.iso_days(), Calendar.time_zone()) ::
-              {:ok, time_zone_period}
-              | {:error, :time_zone_not_found | :utc_only_time_zone_database}
-
-  @doc """
-  Possible time zone periods for a certain time zone and wall clock date and time.
-
-  When the provided `datetime` is ambiguous a tuple with `:ambiguous` and two possible
-  periods. The periods in the list are sorted with the first element being the one that begins first.
-
-  When the provided `datetime` is in a gap - for instance during the "spring forward" when going
-  from winter time to summer time, a tuple with `:gap` and two periods with limits are returned
-  in a nested tuple. The first nested two-tuple is the period before the gap and a naive datetime
-  with a limit for when the period ends (wall time). The second nested two-tuple is the period
-  just after the gap and a datetime (wall time) for when the period begins just after the gap.
-
-  If there is only a single possible period for the provided `datetime`, the a tuple with `:single`
-  and the `time_zone_period` is returned.
-  """
-  @doc since: "1.8.0"
-  @callback time_zone_periods_from_wall_datetime(Calendar.naive_datetime(), Calendar.time_zone()) ::
-              {:ok, time_zone_period}
-              | {:ambiguous, time_zone_period, time_zone_period}
-              | {:gap, {time_zone_period, time_zone_period_limit},
-                 {time_zone_period, time_zone_period_limit}}
-              | {:error, :time_zone_not_found | :utc_only_time_zone_database}
-end
-
-defmodule Calendar.UTCOnlyTimeZoneDatabase do
-  @moduledoc """
-  Built-in time zone database that works only in Etc/UTC.
-
-  For all other time zones, it returns `{:error, :utc_only_time_zone_database}`.
-  """
-
-  @behaviour Calendar.TimeZoneDatabase
-
-  @impl true
-  def time_zone_period_from_utc_iso_days(_, "Etc/UTC"),
-    do: {:ok, %{std_offset: 0, utc_offset: 0, zone_abbr: "UTC"}}
-
-  def time_zone_period_from_utc_iso_days(_, _),
-    do: {:error, :utc_only_time_zone_database}
-
-  @impl true
-  def time_zone_periods_from_wall_datetime(_, "Etc/UTC"),
-    do: {:ok, %{std_offset: 0, utc_offset: 0, zone_abbr: "UTC"}}
-
-  def time_zone_periods_from_wall_datetime(_, _),
-    do: {:error, :utc_only_time_zone_database}
-end

lib/elixir/lib/code/identifier.ex

@@ -1,288 +0,0 @@
-defmodule Code.Identifier do
-  @moduledoc false
-
-  @doc """
-  Checks if the given identifier is an unary op.
-
-  ## Examples
-
-      iex> Code.Identifier.unary_op(:+)
-      {:non_associative, 300}
-
-  """
-  @spec unary_op(atom) :: {:non_associative, precedence :: pos_integer} | :error
-  def unary_op(op) do
-    cond do
-      op in [:&] -> {:non_associative, 90}
-      op in [:!, :^, :not, :+, :-, :~~~] -> {:non_associative, 300}
-      op in [:@] -> {:non_associative, 320}
-      true -> :error
-    end
-  end
-
-  @doc """
-  Checks if the given identifier is a binary op.
-
-  ## Examples
-
-      iex> Code.Identifier.binary_op(:+)
-      {:left, 210}
-
-  """
-  @spec binary_op(atom) :: {:left | :right, precedence :: pos_integer} | :error
-  def binary_op(op) do
-    cond do
-      op in [:<-, :\\] -> {:left, 40}
-      op in [:when] -> {:right, 50}
-      op in [:"::"] -> {:right, 60}
-      op in [:|] -> {:right, 70}
-      op in [:=] -> {:right, 100}
-      op in [:||, :|||, :or] -> {:left, 130}
-      op in [:&&, :&&&, :and] -> {:left, 140}
-      op in [:==, :!=, :=~, :===, :!==] -> {:left, 150}
-      op in [:<, :<=, :>=, :>] -> {:left, 160}
-      op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :<|>] -> {:left, 170}
-      op in [:in] -> {:left, 180}
-      op in [:^^^] -> {:left, 190}
-      op in [:++, :--, :.., :<>] -> {:right, 200}
-      op in [:+, :-] -> {:left, 210}
-      op in [:*, :/] -> {:left, 220}
-      op in [:.] -> {:left, 310}
-      true -> :error
-    end
-  end
-
-  @doc """
-  Classifies the given atom into one of the following categories:
-
-    * `:alias` - a valid Elixir alias, like `Foo`, `Foo.Bar` and so on
-
-    * `:callable_local` - an atom that can be used as a local call;
-      this category includes identifiers like `:foo`
-
-    * `:callable_operator` - all callable operators, such as `:<>`. Note
-      operators such as `:..` are not callable because of ambiguity
-
-    * `:not_atomable` - callable operators that must be wrapped in quotes when
-      defined as an atom. For example, `::` must be written as `:"::"` to avoid
-      the ambiguity between the atom and the keyword identifier
-
-    * `:not_callable` - an atom that cannot be used as a function call after the
-      `.` operator (for example, `:<<>>` is not callable because `Foo.<<>>` is a
-      syntax error); this category includes atoms like `:Foo`, since they are
-      valid identifiers but they need quotes to be used in function calls
-      (`Foo."Bar"`)
-
-    * `:other` - any other atom (these are usually escaped when inspected, like
-      `:"foo and bar"`)
-
-  """
-  def classify(atom) when is_atom(atom) do
-    charlist = Atom.to_charlist(atom)
-
-    cond do
-      atom in [:%, :%{}, :{}, :<<>>, :..., :.., :., :->] ->
-        :not_callable
-
-      atom in [:"::"] ->
-        :not_atomable
-
-      unary_op(atom) != :error or binary_op(atom) != :error ->
-        :callable_operator
-
-      valid_alias?(charlist) ->
-        :alias
-
-      true ->
-        case :elixir_config.get(:identifier_tokenizer, String.Tokenizer).tokenize(charlist) do
-          {kind, _acc, [], _, _, special} ->
-            if kind == :identifier and not :lists.member(?@, special) do
-              :callable_local
-            else
-              :not_callable
-            end
-
-          _ ->
-            :other
-        end
-    end
-  end
-
-  defp valid_alias?('Elixir' ++ rest), do: valid_alias_piece?(rest)
-  defp valid_alias?(_other), do: false
-
-  defp valid_alias_piece?([?., char | rest]) when char >= ?A and char <= ?Z,
-    do: valid_alias_piece?(trim_leading_while_valid_identifier(rest))
-
-  defp valid_alias_piece?([]), do: true
-  defp valid_alias_piece?(_other), do: false
-
-  defp trim_leading_while_valid_identifier([char | rest])
-       when char >= ?a and char <= ?z
-       when char >= ?A and char <= ?Z
-       when char >= ?0 and char <= ?9
-       when char == ?_ do
-    trim_leading_while_valid_identifier(rest)
-  end
-
-  defp trim_leading_while_valid_identifier(other) do
-    other
-  end
-
-  @doc """
-  Inspects the identifier as an atom.
-  """
-  def inspect_as_atom(atom) when is_nil(atom) or is_boolean(atom) do
-    Atom.to_string(atom)
-  end
-
-  def inspect_as_atom(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case classify(atom) do
-      :alias ->
-        case binary do
-          binary when binary in ["Elixir", "Elixir.Elixir"] -> binary
-          "Elixir.Elixir." <> _rest -> binary
-          "Elixir." <> rest -> rest
-        end
-
-      type when type in [:callable_local, :callable_operator, :not_callable] ->
-        ":" <> binary
-
-      _ ->
-        {escaped, _} = escape(binary, ?")
-        IO.iodata_to_binary([?:, ?", escaped, ?"])
-    end
-  end
-
-  @doc """
-  Inspects the given identifier as a key.
-  """
-  def inspect_as_key(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case classify(atom) do
-      type when type in [:callable_local, :callable_operator, :not_callable] ->
-        IO.iodata_to_binary([binary, ?:])
-
-      _ ->
-        {escaped, _} = escape(binary, ?")
-        IO.iodata_to_binary([?", escaped, ?", ?:])
-    end
-  end
-
-  @doc """
-  Inspects the given identifier as a function name.
-  """
-  def inspect_as_function(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case classify(atom) do
-      type when type in [:callable_local, :callable_operator, :not_atomable] ->
-        binary
-
-      type ->
-        escaped =
-          if type in [:not_callable, :alias] do
-            binary
-          else
-            elem(escape(binary, ?"), 0)
-          end
-
-        IO.iodata_to_binary([?", escaped, ?"])
-    end
-  end
-
-  @doc """
-  Extracts the name and arity of the parent from the anonymous function identifier.
-  """
-  # Example of this format: -NAME/ARITY-fun-COUNT-
-  def extract_anonymous_fun_parent(atom) when is_atom(atom) do
-    with "-" <> rest <- Atom.to_string(atom),
-         [trailing | reversed] = rest |> String.split("/") |> Enum.reverse(),
-         [arity, _inner, _count, ""] <- String.split(trailing, "-") do
-      {reversed |> Enum.reverse() |> Enum.join("/") |> String.to_atom(), arity}
-    else
-      _ -> :error
-    end
-  end
-
-  @doc """
-  Escapes the given identifier.
-  """
-  def escape(other, char, count \\ :infinity, fun \\ &escape_map/1) do
-    escape(other, char, count, [], fun)
-  end
-
-  defp escape(<<_, _::binary>> = binary, _char, 0, acc, _fun) do
-    {acc, binary}
-  end
-
-  defp escape(<<char, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), [acc | [?\\, char]], fun)
-  end
-
-  defp escape(<<?#, ?{, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), [acc | '\\\#{'], fun)
-  end
-
-  defp escape(<<h::utf8, t::binary>>, char, count, acc, fun) do
-    escaped = if value = fun.(h), do: value, else: escape_char(h)
-    escape(t, char, decrement(count), [acc | escaped], fun)
-  end
-
-  defp escape(<<a::4, b::4, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), [acc | ['\\x', to_hex(a), to_hex(b)]], fun)
-  end
-
-  defp escape(<<>>, _char, _count, acc, _fun) do
-    {acc, <<>>}
-  end
-
-  defp escape_char(0), do: '\\0'
-
-  defp escape_char(65279), do: '\\uFEFF'
-
-  defp escape_char(char)
-       when char in 0x20..0x7E
-       when char in 0xA0..0xD7FF
-       when char in 0xE000..0xFFFD
-       when char in 0x10000..0x10FFFF do
-    <<char::utf8>>
-  end
-
-  defp escape_char(char) when char < 0x100 do
-    <<a::4, b::4>> = <<char::8>>
-    ['\\x', to_hex(a), to_hex(b)]
-  end
-
-  defp escape_char(char) when char < 0x10000 do
-    <<a::4, b::4, c::4, d::4>> = <<char::16>>
-    ['\\x{', to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}]
-  end
-
-  defp escape_char(char) when char < 0x1000000 do
-    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
-    ['\\x{', to_hex(a), to_hex(b), to_hex(c), to_hex(d), to_hex(e), to_hex(f), ?}]
-  end
-
-  defp escape_map(?\a), do: '\\a'
-  defp escape_map(?\b), do: '\\b'
-  defp escape_map(?\d), do: '\\d'
-  defp escape_map(?\e), do: '\\e'
-  defp escape_map(?\f), do: '\\f'
-  defp escape_map(?\n), do: '\\n'
-  defp escape_map(?\r), do: '\\r'
-  defp escape_map(?\t), do: '\\t'
-  defp escape_map(?\v), do: '\\v'
-  defp escape_map(?\\), do: '\\\\'
-  defp escape_map(_), do: false
-
-  @compile {:inline, to_hex: 1, decrement: 1}
-  defp to_hex(c) when c in 0..9, do: ?0 + c
-  defp to_hex(c) when c in 10..15, do: ?A + c - 10
-
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter), do: counter - 1
-end

lib/elixir/lib/code/typespec.ex

@@ -1,417 +0,0 @@
-defmodule Code.Typespec do
-  @moduledoc false
-
-  @doc """
-  Converts a spec clause back to Elixir quoted expression.
-  """
-  @spec spec_to_quoted(atom, tuple) :: {atom, keyword, [Macro.t()]}
-  def spec_to_quoted(name, spec)
-
-  def spec_to_quoted(name, {:type, line, :fun, [{:type, _, :product, args}, result]})
-      when is_atom(name) do
-    meta = [line: line]
-    body = {name, meta, Enum.map(args, &typespec_to_quoted/1)}
-
-    vars =
-      for type_expr <- args ++ [result],
-          var <- collect_vars(type_expr),
-          uniq: true,
-          do: {var, {:var, meta, nil}}
-
-    spec = {:"::", meta, [body, typespec_to_quoted(result)]}
-
-    if vars == [] do
-      spec
-    else
-      {:when, meta, [spec, vars]}
-    end
-  end
-
-  def spec_to_quoted(name, {:type, line, :fun, []}) when is_atom(name) do
-    {:"::", [line: line], [{name, [line: line], []}, quote(do: term)]}
-  end
-
-  def spec_to_quoted(name, {:type, line, :bounded_fun, [type, constrs]}) when is_atom(name) do
-    {:type, _, :fun, [{:type, _, :product, args}, result]} = type
-
-    guards =
-      for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constrs do
-        {erl_to_ex_var(var), typespec_to_quoted(type)}
-      end
-
-    meta = [line: line]
-    ignore_vars = Keyword.keys(guards)
-
-    vars =
-      for type_expr <- args ++ [result],
-          var <- collect_vars(type_expr),
-          var not in ignore_vars,
-          uniq: true,
-          do: {var, {:var, meta, nil}}
-
-    args = for arg <- args, do: typespec_to_quoted(arg)
-
-    when_args = [
-      {:"::", meta, [{name, [line: line], args}, typespec_to_quoted(result)]},
-      guards ++ vars
-    ]
-
-    {:when, meta, when_args}
-  end
-
-  @doc """
-  Converts a type clause back to Elixir AST.
-  """
-  def type_to_quoted(type)
-
-  def type_to_quoted({{:record, record}, fields, args}) when is_atom(record) do
-    fields = for field <- fields, do: typespec_to_quoted(field)
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    type = {:{}, [], [record | fields]}
-    quote(do: unquote(record)(unquote_splicing(args)) :: unquote(type))
-  end
-
-  def type_to_quoted({name, type, args}) when is_atom(name) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    quote(do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_quoted(type)))
-  end
-
-  @doc """
-  Returns all types available from the module's BEAM code.
-
-  The result is returned as a list of tuples where the first
-  element is the type (`:typep`, `:type` and `:opaque`).
-
-  The module must have a corresponding BEAM file which can be
-  located by the runtime system. The types will be in the Erlang
-  Abstract Format.
-  """
-  @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error
-  def fetch_types(module) when is_atom(module) or is_binary(module) do
-    case typespecs_abstract_code(module) do
-      {:ok, abstract_code} ->
-        exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types
-        exported_types = List.flatten(exported_types)
-
-        types =
-          for {:attribute, _, kind, {name, _, args} = type} <- abstract_code,
-              kind in [:opaque, :type] do
-            cond do
-              kind == :opaque -> {:opaque, type}
-              {name, length(args)} in exported_types -> {:type, type}
-              true -> {:typep, type}
-            end
-          end
-
-        {:ok, types}
-
-      _ ->
-        :error
-    end
-  end
-
-  @doc """
-  Returns all specs available from the module's BEAM code.
-
-  The result is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module must have a corresponding BEAM file which can be
-  located by the runtime system. The types will be in the Erlang
-  Abstract Format.
-  """
-  @spec fetch_specs(module) :: {:ok, [tuple]} | :error
-  def fetch_specs(module) when is_atom(module) or is_binary(module) do
-    case typespecs_abstract_code(module) do
-      {:ok, abstract_code} ->
-        {:ok, for({:attribute, _, :spec, value} <- abstract_code, do: value)}
-
-      :error ->
-        :error
-    end
-  end
-
-  @doc """
-  Returns all callbacks available from the module's BEAM code.
-
-  The result is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module must have a corresponding BEAM file
-  which can be located by the runtime system. The types will be
-  in the Erlang Abstract Format.
-  """
-  @spec fetch_callbacks(module) :: {:ok, [tuple]} | :error
-  def fetch_callbacks(module) when is_atom(module) or is_binary(module) do
-    case typespecs_abstract_code(module) do
-      {:ok, abstract_code} ->
-        {:ok, for({:attribute, _, :callback, value} <- abstract_code, do: value)}
-
-      :error ->
-        :error
-    end
-  end
-
-  defp typespecs_abstract_code(module) do
-    with {module, binary} <- get_module_and_beam(module),
-         {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} <-
-           :beam_lib.chunks(binary, [:debug_info]) do
-      case data do
-        {:elixir_v1, %{}, specs} ->
-          # Fast path to avoid translation to Erlang from Elixir.
-          {:ok, specs}
-
-        _ ->
-          case backend.debug_info(:erlang_v1, module, data, []) do
-            {:ok, abstract_code} -> {:ok, abstract_code}
-            _ -> :error
-          end
-      end
-    else
-      _ -> :error
-    end
-  end
-
-  defp get_module_and_beam(module) when is_atom(module) do
-    case :code.get_object_code(module) do
-      {^module, beam, _filename} -> {module, beam}
-      :error -> :error
-    end
-  end
-
-  defp get_module_and_beam(beam) when is_binary(beam) do
-    case :beam_lib.info(beam) do
-      [_ | _] = info -> {info[:module], beam}
-      _ -> :error
-    end
-  end
-
-  ## To AST conversion
-
-  defp collect_vars({:ann_type, _line, args}) when is_list(args) do
-    []
-  end
-
-  defp collect_vars({:type, _line, _kind, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
-  end
-
-  defp collect_vars({:remote_type, _line, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
-  end
-
-  defp collect_vars({:typed_record_field, _line, type}) do
-    collect_vars(type)
-  end
-
-  defp collect_vars({:paren_type, _line, [type]}) do
-    collect_vars(type)
-  end
-
-  defp collect_vars({:var, _line, var}) do
-    [erl_to_ex_var(var)]
-  end
-
-  defp collect_vars(_) do
-    []
-  end
-
-  defp typespec_to_quoted({:user_type, line, name, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {name, [line: line], args}
-  end
-
-  defp typespec_to_quoted({:type, line, :tuple, :any}) do
-    {:tuple, [line: line], []}
-  end
-
-  defp typespec_to_quoted({:type, line, :tuple, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {:{}, [line: line], args}
-  end
-
-  defp typespec_to_quoted({:type, _line, :list, [{:type, _, :union, unions} = arg]}) do
-    case unpack_typespec_kw(unions, []) do
-      {:ok, ast} -> ast
-      :error -> [typespec_to_quoted(arg)]
-    end
-  end
-
-  defp typespec_to_quoted({:type, line, :list, []}) do
-    {:list, [line: line], []}
-  end
-
-  defp typespec_to_quoted({:type, _line, :list, [arg]}) do
-    [typespec_to_quoted(arg)]
-  end
-
-  defp typespec_to_quoted({:type, line, :nonempty_list, []}) do
-    [{:..., [line: line], nil}]
-  end
-
-  defp typespec_to_quoted({:type, line, :nonempty_list, [arg]}) do
-    [typespec_to_quoted(arg), {:..., [line: line], nil}]
-  end
-
-  defp typespec_to_quoted({:type, line, :map, :any}) do
-    {:map, [line: line], []}
-  end
-
-  defp typespec_to_quoted({:type, line, :map, fields}) do
-    fields =
-      Enum.map(fields, fn
-        {:type, _, :map_field_assoc, :any} ->
-          {{:optional, [], [{:any, [], []}]}, {:any, [], []}}
-
-        {:type, _, :map_field_exact, [{:atom, _, k}, v]} ->
-          {k, typespec_to_quoted(v)}
-
-        {:type, _, :map_field_exact, [k, v]} ->
-          {{:required, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}
-
-        {:type, _, :map_field_assoc, [k, v]} ->
-          {{:optional, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}
-      end)
-
-    {struct, fields} = Keyword.pop(fields, :__struct__)
-    map = {:%{}, [line: line], fields}
-
-    if struct do
-      {:%, [line: line], [struct, map]}
-    else
-      map
-    end
-  end
-
-  defp typespec_to_quoted({:type, line, :binary, [arg1, arg2]}) do
-    [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_quoted(arg)
-
-    case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do
-      {arg1, 0} ->
-        quote(line: line, do: <<_::unquote(arg1)>>)
-
-      {0, arg2} ->
-        quote(line: line, do: <<_::_*unquote(arg2)>>)
-
-      {arg1, arg2} ->
-        quote(line: line, do: <<_::unquote(arg1), _::_*unquote(arg2)>>)
-    end
-  end
-
-  defp typespec_to_quoted({:type, line, :union, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, [line: line], [arg, expr]} end)
-  end
-
-  defp typespec_to_quoted({:type, line, :fun, [{:type, _, :product, args}, result]}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    [{:->, [line: line], [args, typespec_to_quoted(result)]}]
-  end
-
-  defp typespec_to_quoted({:type, line, :fun, [args, result]}) do
-    [{:->, [line: line], [[typespec_to_quoted(args)], typespec_to_quoted(result)]}]
-  end
-
-  defp typespec_to_quoted({:type, line, :fun, []}) do
-    typespec_to_quoted({:type, line, :fun, [{:type, line, :any}, {:type, line, :any, []}]})
-  end
-
-  defp typespec_to_quoted({:type, line, :range, [left, right]}) do
-    {:.., [line: line], [typespec_to_quoted(left), typespec_to_quoted(right)]}
-  end
-
-  defp typespec_to_quoted({:type, _line, nil, []}) do
-    []
-  end
-
-  defp typespec_to_quoted({:type, line, name, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {name, [line: line], args}
-  end
-
-  defp typespec_to_quoted({:var, line, var}) do
-    {erl_to_ex_var(var), [line: line], nil}
-  end
-
-  defp typespec_to_quoted({:op, line, op, arg}) do
-    {op, [line: line], [typespec_to_quoted(arg)]}
-  end
-
-  defp typespec_to_quoted({:remote_type, line, [mod, name, args]}) do
-    remote_type(line, mod, name, args)
-  end
-
-  defp typespec_to_quoted({:ann_type, line, [var, type]}) do
-    {:"::", [line: line], [typespec_to_quoted(var), typespec_to_quoted(type)]}
-  end
-
-  defp typespec_to_quoted(
-         {:typed_record_field, {:record_field, line, {:atom, line1, name}}, type}
-       ) do
-    typespec_to_quoted({:ann_type, line, [{:var, line1, name}, type]})
-  end
-
-  defp typespec_to_quoted({:type, _, :any}) do
-    quote(do: ...)
-  end
-
-  defp typespec_to_quoted({:paren_type, _, [type]}) do
-    typespec_to_quoted(type)
-  end
-
-  defp typespec_to_quoted({type, _line, atom}) when is_atom(type) do
-    atom
-  end
-
-  defp typespec_to_quoted(other), do: other
-
-  ## Helpers
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do
-    typespec_to_quoted({:type, line, :charlist, []})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do
-    typespec_to_quoted({:type, line, :nonempty_charlist, []})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :struct}, []) do
-    typespec_to_quoted({:type, line, :struct, []})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do
-    typespec_to_quoted({:type, line, :as_boolean, [arg]})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do
-    typespec_to_quoted({:type, line, :keyword, args})
-  end
-
-  defp remote_type(line, mod, name, args) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    dot = {:., [line: line], [typespec_to_quoted(mod), typespec_to_quoted(name)]}
-    {dot, [line: line], args}
-  end
-
-  defp erl_to_ex_var(var) do
-    case Atom.to_string(var) do
-      <<"_", c::utf8, rest::binary>> ->
-        String.to_atom("_#{String.downcase(<<c::utf8>>)}#{rest}")
-
-      <<c::utf8, rest::binary>> ->
-        String.to_atom("#{String.downcase(<<c::utf8>>)}#{rest}")
-    end
-  end
-
-  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do
-    unpack_typespec_kw(t, [{atom, typespec_to_quoted(type)} | acc])
-  end
-
-  defp unpack_typespec_kw([], acc) do
-    {:ok, Enum.reverse(acc)}
-  end
-
-  defp unpack_typespec_kw(_, _acc) do
-    :error
-  end
-end

lib/elixir/lib/collectable.ex

@@ -21,57 +21,26 @@ defprotocol Collectable do
   shape where just the range limits are stored.
 
   The `Collectable` module was designed to fill the gap left by the
-  `Enumerable` protocol. `Collectable.into/1` can be seen as the opposite of
-  `Enumerable.reduce/3`. If the functions in `Enumerable` are about taking values out,
-  then `Collectable.into/1` is about collecting those values into a structure.
-
-  ## Examples
-
-  To show how to manually use the `Collectable` protocol, let's play with its
-  implementation for `MapSet`.
-
-      iex> {initial_acc, collector_fun} = Collectable.into(MapSet.new())
-      iex> updated_acc = Enum.reduce([1, 2, 3], initial_acc, fn elem, acc ->
-      ...>   collector_fun.(acc, {:cont, elem})
-      ...> end)
-      iex> collector_fun.(updated_acc, :done)
-      #MapSet<[1, 2, 3]>
-
-  To show how the protocol can be implemented, we can again look at the
-  implementation for `MapSet`. In this implementation "collecting" elements
-  simply means inserting them in the set through `MapSet.put/2`.
-
-      defimpl Collectable, for: MapSet do
-        def into(original) do
-          collector_fun = fn
-            set, {:cont, elem} -> MapSet.put(set, elem)
-            set, :done -> set
-            _set, :halt -> :ok
-          end
-
-          {original, collector_fun}
-        end
-      end
-
+  `Enumerable` protocol. `into/1` can be seen as the opposite of
+  `Enumerable.reduce/3`. If `Enumerable` is about taking values out,
+  `Collectable.into/1` is about collecting those values into a structure.
   """
 
   @type command :: {:cont, term} | :done | :halt
 
   @doc """
-  Returns an initial accumulator and a "collector" function.
+  Returns a function that collects values alongside
+  the initial accumulation value.
 
-  The returned function receives a term and a command and injects the term into
-  the collectable on every `{:cont, term}` command.
+  The returned function receives a collectable and injects a given
+  value into it for every `{:cont, term}` instruction.
 
-  `:done` is passed as a command when no further values will be injected. This
-  is useful when there's a need to close resources or normalizing values. A
-  collectable must be returned when the command is `:done`.
+  `:done` is passed when no further values will be injected, useful
+  for closing resources and normalizing values. A collectable must
+  be returned on `:done`.
 
-  If injection is suddenly interrupted, `:halt` is passed and the function
-  can return any value as it won't be used.
-
-  For examples on how to use the `Collectable` protocol and `into/1` see the
-  module documentation.
+  If injection is suddenly interrupted, `:halt` is passed and it can
+  return any value, as it won't be used.
   """
   @spec into(t) :: {term, (term, command -> t | term)}
   def into(collectable)
@@ -79,75 +48,30 @@ end
 
 defimpl Collectable, for: List do
   def into(original) do
-    if original != [] do
-      IO.warn(
-        "the Collectable protocol is deprecated for non-empty lists. The behaviour of " <>
-          "things like Enum.into/2 or \"for\" comprehensions with an :into option is incorrect " <>
-          "when collecting into non-empty lists. If you're collecting into a non-empty keyword " <>
-          "list, consider using Keyword.merge/2 instead. If you're collecting into a non-empty " <>
-          "list, consider concatenating the two lists with the ++ operator."
-      )
-    end
-
-    fun = fn
+    {[], fn
       list, {:cont, x} -> [x | list]
       list, :done -> original ++ :lists.reverse(list)
       _, :halt -> :ok
-    end
-
-    {[], fun}
+    end}
   end
 end
 
 defimpl Collectable, for: BitString do
-  def into(original) when is_binary(original) do
-    fun = fn
-      acc, {:cont, x} when is_binary(x) and is_list(acc) ->
-        [acc | x]
-
-      acc, {:cont, x} when is_bitstring(x) and is_bitstring(acc) ->
-        <<acc::bitstring, x::bitstring>>
-
-      acc, {:cont, x} when is_bitstring(x) ->
-        <<IO.iodata_to_binary(acc)::bitstring, x::bitstring>>
-
-      acc, :done when is_bitstring(acc) ->
-        acc
-
-      acc, :done ->
-        IO.iodata_to_binary(acc)
-
-      _, :halt ->
-        :ok
-    end
-
-    {[original], fun}
-  end
-
-  def into(original) when is_bitstring(original) do
-    fun = fn
-      acc, {:cont, x} when is_bitstring(x) ->
-        <<acc::bitstring, x::bitstring>>
-
-      acc, :done ->
-        acc
-
-      _, :halt ->
-        :ok
-    end
-
-    {original, fun}
+  def into(original) do
+    {original, fn
+      acc, {:cont, x} when is_bitstring(x) -> [acc | x]
+      acc, :done -> IO.iodata_to_binary(acc)
+      _, :halt -> :ok
+    end}
   end
 end
 
 defimpl Collectable, for: Map do
   def into(original) do
-    fun = fn
-      map, {:cont, {k, v}} -> Map.put(map, k, v)
+    {original, fn
+      map, {:cont, {k, v}} -> :maps.put(k, v, map)
       map, :done -> map
       _, :halt -> :ok
-    end
-
-    {original, fun}
+    end}
   end
 end

lib/elixir/lib/config.ex

@@ -1,266 +0,0 @@
-defmodule Config do
-  @moduledoc ~S"""
-  A simple keyword-based configuration API.
-
-  ## Example
-
-  This module is most commonly used to define application configuration,
-  typically in `config/config.exs`:
-
-      import Config
-
-      config :some_app,
-        key1: "value1",
-        key2: "value2"
-
-      import_config "#{Mix.env()}.exs"
-
-  `import Config` will import the functions `config/2`, `config/3`
-  and `import_config/1` to help you manage your configuration.
-
-  `config/2` and `config/3` are used to define key-value configuration
-  for a given application. Once Mix starts, it will automatically
-  evaluate the configuration file and persist the configuration above
-  into `:some_app`'s application environment, which can be accessed in
-  as follows:
-
-      "value1" = Application.fetch_env!(:some_app, :key1)
-
-  Finally, the line `import_config "#{Mix.env()}.exs"` will import other
-  config files, based on the current Mix environment, such as
-  `config/dev.exs` and `config/test.exs`.
-
-  `Config` also provides a low-level API for evaluating and reading
-  configuration, under the `Config.Reader` module.
-
-  **Important:** if you are writing a library to be used by other developers,
-  it is generally recommended to avoid the application environment, as the
-  application environment is effectively a global storage. For more information,
-  read our [library guidelines](library-guidelines.html).
-
-  ## Migrating from `use Mix.Config`
-
-  The `Config` module in Elixir was introduced in v1.9 as a replacement to
-  `Mix.Config`, which was specific to Mix and has been deprecated.
-
-  You can leverage `Config` instead of `Mix.Config` in two steps. The first
-  step is to replace `use Mix.Config` at the top of your config files by
-  `import Config`.
-
-  The second is to make sure your `import_config/1` calls do not have a
-  wildcard character. If so, you need to perform the wildcard lookup
-  manually. For example, if you did:
-
-      import_config "../apps/*/config/config.exs"
-
-  It has to be replaced by:
-
-      for config <- "../apps/*/config/config.exs" |> Path.expand(__DIR__) |> Path.wildcard() do
-        import_config config
-      end
-
-  ## config/releases.exs
-
-  If you are using releases, see `mix release`, there is another configuration
-  file called `config/releases.exs`. While `config/config.exs` and friends
-  mentioned in the previous section are executed whenever you run a Mix
-  command, including when you assemble a release, `config/releases.exs` is
-  executed every time your production system boots. Since Mix is not available
-  in a production system, `config/releases.exs` must not use any of the
-  functions from Mix.
-  """
-
-  @config_key {__MODULE__, :config}
-  @files_key {__MODULE__, :files}
-
-  defp get_config!() do
-    Process.get(@config_key) || raise_improper_use!()
-  end
-
-  defp put_config(value) do
-    Process.put(@config_key, value)
-  end
-
-  defp delete_config() do
-    Process.delete(@config_key)
-  end
-
-  defp get_files!() do
-    Process.get(@files_key) || raise_improper_use!()
-  end
-
-  defp put_files(value) do
-    Process.put(@files_key, value)
-  end
-
-  defp delete_files() do
-    Process.delete(@files_key)
-  end
-
-  defp raise_improper_use!() do
-    raise "could not set configuration via Config. " <>
-            "This usually means you are trying to execute a configuration file " <>
-            "directly, instead of reading it with Config.Reader"
-  end
-
-  @doc """
-  Configures the given `root_key`.
-
-  Keyword lists are always deep-merged.
-
-  ## Examples
-
-  The given `opts` are merged into the existing configuration
-  for the given `root_key`. Conflicting keys are overridden by the
-  ones specified in `opts`. For example, the application
-  configuration below
-
-      config :logger,
-        level: :warn,
-        backends: [:console]
-
-      config :logger,
-        level: :info,
-        truncate: 1024
-
-  will have a final configuration for `:logger` of:
-
-      [level: :info, backends: [:console], truncate: 1024]
-
-  """
-  @doc since: "1.9.0"
-  def config(root_key, opts) when is_atom(root_key) and is_list(opts) do
-    unless Keyword.keyword?(opts) do
-      raise ArgumentError, "config/2 expected a keyword list, got: #{inspect(opts)}"
-    end
-
-    get_config!()
-    |> __merge__([{root_key, opts}])
-    |> put_config()
-  end
-
-  @doc """
-  Configures the given `key` for the given `root_key`.
-
-  Keyword lists are always deep merged.
-
-  ## Examples
-
-  The given `opts` are merged into the existing values for `key`
-  in the given `root_key`. Conflicting keys are overridden by the
-  ones specified in `opts`. For example, the application
-  configuration below
-
-      config :ecto, Repo,
-        log_level: :warn,
-        adapter: Ecto.Adapters.Postgres
-
-      config :ecto, Repo,
-        log_level: :info,
-        pool_size: 10
-
-  will have a final value of the configuration for the `Repo`
-  key in the `:ecto` application of:
-
-      [log_level: :info, pool_size: 10, adapter: Ecto.Adapters.Postgres]
-
-  """
-  @doc since: "1.9.0"
-  def config(root_key, key, opts) when is_atom(root_key) and is_atom(key) do
-    get_config!()
-    |> __merge__([{root_key, [{key, opts}]}])
-    |> put_config()
-  end
-
-  @doc ~S"""
-  Imports configuration from the given file.
-
-  In case the file doesn't exist, an error is raised.
-
-  If file is a relative, it will be expanded relatively to the
-  directory the current configuration file is in.
-
-  ## Examples
-
-  This is often used to emulate configuration across environments:
-
-      import_config "#{Mix.env()}.exs"
-
-  """
-  @doc since: "1.9.0"
-  defmacro import_config(file) do
-    quote do
-      Config.__import__!(Path.expand(unquote(file), __DIR__))
-      :ok
-    end
-  end
-
-  @doc false
-  @spec __import__!(Path.t()) :: {term, Code.binding()}
-  def __import__!(file) when is_binary(file) do
-    current_files = get_files!()
-
-    if file in current_files do
-      raise ArgumentError,
-            "attempting to load configuration #{Path.relative_to_cwd(file)} recursively"
-    end
-
-    put_files([file | current_files])
-    Code.eval_file(file)
-  end
-
-  @doc false
-  @spec __eval__!(Path.t(), [Path.t()]) :: {keyword, [Path.t()]}
-  def __eval__!(file, imported_paths \\ []) when is_binary(file) and is_list(imported_paths) do
-    previous_config = put_config([])
-    previous_files = put_files(imported_paths)
-
-    try do
-      {eval_config, _} = __import__!(Path.expand(file))
-
-      case get_config!() do
-        [] when is_list(eval_config) ->
-          {validate!(eval_config, file), get_files!()}
-
-        pdict_config ->
-          {pdict_config, get_files!()}
-      end
-    after
-      if previous_config, do: put_config(previous_config), else: delete_config()
-      if previous_files, do: put_files(previous_files), else: delete_files()
-    end
-  end
-
-  @doc false
-  def __merge__(config1, config2) when is_list(config1) and is_list(config2) do
-    Keyword.merge(config1, config2, fn _, app1, app2 ->
-      Keyword.merge(app1, app2, &deep_merge/3)
-    end)
-  end
-
-  defp deep_merge(_key, value1, value2) do
-    if Keyword.keyword?(value1) and Keyword.keyword?(value2) do
-      Keyword.merge(value1, value2, &deep_merge/3)
-    else
-      value2
-    end
-  end
-
-  defp validate!(config, file) do
-    Enum.all?(config, fn
-      {app, value} when is_atom(app) ->
-        if Keyword.keyword?(value) do
-          true
-        else
-          raise ArgumentError,
-                "expected config for app #{inspect(app)} in #{Path.relative_to_cwd(file)} " <>
-                  "to return keyword list, got: #{inspect(value)}"
-        end
-
-      _ ->
-        false
-    end)
-
-    config
-  end
-end

lib/elixir/lib/config/provider.ex

@@ -1,377 +0,0 @@
-defmodule Config.Provider do
-  @moduledoc """
-  Specifies a provider API that loads configuration during boot.
-
-  Config providers are typically used during releases to load
-  external configuration while the system boots. This is done
-  by starting the VM with the minimum amount of applications
-  running, then invoking all of the providers, and then
-  restarting the system. This requires a mutable configuration
-  file on disk, as the results of the providers are written to
-  the file system. For more information on runtime configuration,
-  see `mix release`.
-
-  ## Sample config provider
-
-  For example, imagine you need to load some configuration from
-  a JSON file and load that into the system. Said configuration
-  provider would look like:
-
-      defmodule JSONConfigProvider do
-        @behaviour Config.Provider
-
-        # Let's pass the path to the JSON file as config
-        def init(path) when is_binary(path), do: path
-
-        def load(config, path) do
-          # We need to start any app we may depend on.
-          {:ok, _} = Application.ensure_all_started(:jason)
-
-          json = path |> File.read!() |> Jason.decode!()
-
-          Config.Reader.merge(
-            config,
-            my_app: [
-              some_value: json["my_app_some_value"],
-              another_value: json["my_app_another_value"],
-            ]
-          )
-        end
-      end
-
-  Then when specifying your release, you can specify the provider in
-  the release configuration:
-
-      releases: [
-        demo: [
-          # ...,
-          config_providers: [{JSONConfigProvider, "/etc/config.json"}]
-        ]
-      ]
-
-  Now once the system boots, it will invoke the provider early in
-  the boot process, save the merged configuration to the disk, and
-  reboot the system with the new values in place.
-  """
-
-  @type config :: keyword
-  @type state :: term
-
-  @typedoc """
-  A path pointing to a configuration file.
-
-  Since configuration files are often accessed on target machines,
-  it can be expressed either as:
-
-    * a binary representing an absolute path
-
-    * a `{:system, system_var, path}` tuple where the config is the
-      concatenation of the environment variable `system_var` with
-      the given `path`
-
-  """
-  @type config_path :: {:system, binary(), binary()} | binary()
-
-  @doc """
-  Invoked when initializing a config provider.
-
-  A config provider is typically initialized on the machine
-  where the system is assembled and not on the target machine.
-  The `c:init/1` callback is useful to verify the arguments
-  given to the provider and prepare the state that will be
-  given to `c:load/2`.
-
-  Furthermore, because the state returned by `c:init/1` can
-  be written to text-based config files, it should be
-  restricted only to simple data types, such as integers,
-  strings, atoms, tuples, maps, and lists. Entries such as
-  PIDs, references, and functions cannot be serialized.
-  """
-  @callback init(term) :: state
-
-  @doc """
-  Loads configuration (typically during system boot).
-
-  It receives the current `config` and the `state` returned by
-  `c:init/1`. Then you typically read the extra configuration
-  from an external source and merge it into the received `config`.
-  Merging should be done with `Config.Reader.merge/2`, as it
-  performs deep merge. It should return the updated config.
-
-  Note that `c:load/2` is typically invoked very early in the
-  boot process, therefore if you need to use an application
-  in the provider, it is your responsibility to start it.
-  """
-  @callback load(config, state) :: config
-
-  @doc false
-  defstruct [
-    :providers,
-    :config_path,
-    extra_config: [],
-    prune_after_boot: false,
-    reboot_after_config: true,
-    validate_compile_env: false
-  ]
-
-  @doc """
-  Validates a `t:config_path/0`.
-  """
-  @doc since: "1.9.0"
-  @spec validate_config_path!(config_path) :: :ok
-  def validate_config_path!({:system, name, path})
-      when is_binary(name) and is_binary(path),
-      do: :ok
-
-  def validate_config_path!(path) do
-    if is_binary(path) and Path.type(path) != :relative do
-      :ok
-    else
-      raise ArgumentError, """
-      expected configuration path to be:
-
-        * a binary representing an absolute path
-        * a tuple {:system, system_var, path} where the config is the \
-      concatenation of the `system_var` with the given `path`
-
-      Got: #{inspect(path)}
-      """
-    end
-  end
-
-  @doc """
-  Resolves a `t:config_path/0` to an actual path.
-  """
-  @doc since: "1.9.0"
-  @spec resolve_config_path!(config_path) :: binary
-  def resolve_config_path!(path) when is_binary(path), do: path
-  def resolve_config_path!({:system, name, path}), do: System.fetch_env!(name) <> path
-
-  @doc false
-  def init(providers, config_path, opts \\ []) when is_list(providers) and is_list(opts) do
-    validate_config_path!(config_path)
-    providers = for {provider, init} <- providers, do: {provider, provider.init(init)}
-    struct!(%Config.Provider{config_path: config_path, providers: providers}, opts)
-  end
-
-  @doc false
-  def boot(app, key, restart_fun \\ &restart_and_sleep/0) do
-    # The app with the config provider settings may not
-    # have been loaded at this point, so make sure we load
-    # its environment before querying it.
-    _ = :application.load(app)
-
-    # The config provider typically runs very early in the
-    # release process, so we need to make sure Elixir is started
-    # before we go around running Elixir code.
-    {:ok, _} = :application.ensure_all_started(:elixir)
-
-    # The key we store if the system already booted
-    booted_key = :"#{key}_booted"
-
-    case :application.get_env(app, booted_key) do
-      {:ok, {:booted, path}} ->
-        path && File.rm(path)
-
-        with {:ok, %Config.Provider{} = provider} <- :application.get_env(app, key) do
-          maybe_validate_compile_env(provider)
-        end
-
-        :booted
-
-      _ ->
-        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
-
-  @doc false
-  def validate_compile_env(compile_env) do
-    for {app, [key | path], compile_return} <- compile_env,
-        Application.ensure_loaded(app) == :ok do
-      try do
-        traverse_env(Application.fetch_env(app, key), path)
-      rescue
-        e ->
-          abort("""
-          application #{inspect(app)} failed reading its compile environment #{path(key, path)}:
-
-          #{Exception.format(:error, e, __STACKTRACE__)}
-
-          Expected it to match the compile time value of #{return_to_text(compile_return)}.
-
-          #{compile_env_tips(app)}
-          """)
-      else
-        ^compile_return ->
-          :ok
-
-        runtime_return ->
-          abort("""
-          the application #{inspect(app)} has a different value set #{path(key, path)} \
-          during runtime compared to compile time. Since this application environment entry was \
-          marked as compile time, this difference can lead to different behaviour than expected:
-
-            * Compile time value #{return_to_text(compile_return)}
-            * Runtime value #{return_to_text(runtime_return)}
-
-          #{compile_env_tips(app)}
-          """)
-      end
-    end
-
-    :ok
-  end
-
-  defp path(key, []), do: "for key #{inspect(key)}"
-  defp path(key, path), do: "for path #{inspect(path)} inside key #{inspect(key)}"
-
-  defp compile_env_tips(app),
-    do: """
-    To fix this error, you might:
-
-      * Make the runtime value match the compile time one
-
-      * Recompile your project. If the misconfigured application is a dependency, \
-    you may need to run "mix deps.compile #{app} --force"
-
-      * Alternatively, you can disable this check. If you are using releases, you can \
-    set :validate_compile_env to false in your release configuration. If you are \
-    using Mix to start your system, you can pass the --no-validate-compile-env flag
-    """
-
-  defp return_to_text({:ok, value}), do: "was set to: #{inspect(value)}"
-  defp return_to_text(:error), do: "was not set"
-
-  defp traverse_env(return, []), do: return
-  defp traverse_env(:error, _paths), do: :error
-  defp traverse_env({:ok, value}, [key | keys]), do: traverse_env(Access.fetch(value, key), keys)
-
-  defp restart_and_sleep do
-    :init.restart()
-    Process.sleep(:infinity)
-  end
-
-  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
-      bad_path_abort("Got infinite loop when running Config.Provider", path)
-    else
-      System.put_env("ELIXIR_CONFIG_PROVIDER_BOOTED", "1")
-    end
-  end
-
-  defp read_config!(path) do
-    case :file.consult(path) do
-      {:ok, [inner]} ->
-        inner
-
-      {:error, reason} ->
-        bad_path_abort(
-          "Could not read runtime configuration due to reason: #{inspect(reason)}",
-          path
-        )
-    end
-  end
-
-  defp run_providers(config, %{providers: providers}) do
-    Enum.reduce(providers, config, fn {provider, state}, acc ->
-      try do
-        provider.load(acc, state)
-      catch
-        kind, error ->
-          IO.puts(:stderr, "ERROR! Config provider #{inspect(provider)} failed with:")
-          IO.puts(:stderr, Exception.format(kind, error, __STACKTRACE__))
-          :erlang.raise(kind, error, __STACKTRACE__)
-      else
-        term when is_list(term) ->
-          term
-
-        term ->
-          abort("Expected provider #{inspect(provider)} to return a list, got: #{inspect(term)}")
-      end
-    end)
-  end
-
-  defp write_config!(config, path) do
-    contents = :io_lib.format("%% coding: utf-8~n~tw.~n", [config])
-
-    case File.write(path, IO.chardata_to_string(contents)) do
-      :ok ->
-        :ok
-
-      {:error, reason} ->
-        bad_path_abort(
-          "Could not write runtime configuration due to reason: #{inspect(reason)}",
-          path
-        )
-    end
-  end
-
-  defp bad_path_abort(msg, path) do
-    abort(
-      msg <>
-        ". Please make sure #{inspect(path)} is writable and accessible " <>
-        "or choose a different path"
-    )
-  end
-
-  defp abort(msg) do
-    IO.puts(:stderr, "ERROR! " <> msg)
-    :erlang.raise(:error, "aborting boot", [{Config.Provider, :boot, 2, []}])
-  end
-end

lib/elixir/lib/config/reader.ex

@@ -1,100 +0,0 @@
-defmodule Config.Reader do
-  @moduledoc """
-  API for reading config files defined with `Config`.
-
-  ## As a provider
-
-  `Config.Reader` can also be used as a `Config.Provider`. When used
-  as a provider, it expects a single argument: the configuration path
-  (as outlined in `t:Config.Provider.config_path/0`) for the file to
-  be read and loaded during the system boot.
-
-  For example, if you expect the target system to have a config file
-  in an absolute path, you can configure your `mix release` as:
-
-      config_providers: [{Config.Reader, "/etc/config.exs"}]
-
-  Or if you want to read a custom path inside the release:
-
-      config_provider: [{Config.Reader, {:system, "RELEASE_ROOT", "/config.exs"}}]
-
-  Note by default Mix releases supports runtime configuration via
-  a `config/releases.exs`. If a `config/releases.exs` exists in your
-  application, it is automatically copied inside the release and
-  automatically set as a config provider.
-  """
-
-  @behaviour Config.Provider
-
-  @impl true
-  def init(path) do
-    Config.Provider.validate_config_path!(path)
-    path
-  end
-
-  @impl true
-  def load(config, path) do
-    merge(config, path |> Config.Provider.resolve_config_path!() |> read!())
-  end
-
-  @doc """
-  Reads the configuration file.
-
-  The same as `read_imports!/2` but only returns the configuration
-  in the given file, without returning the imported paths.
-
-  It exists for convenience purposes. For example, you could
-  invoke it inside your `mix.exs` to read some external data
-  you decided to move to a configuration file:
-
-      releases: Config.Reader.read!("rel/releases.exs")
-
-  """
-  @doc since: "1.9.0"
-  @spec read!(Path.t(), [Path.t()]) :: keyword
-  def read!(file, imported_paths \\ [])
-      when is_binary(file) and is_list(imported_paths) do
-    Config.__eval__!(file, imported_paths) |> elem(0)
-  end
-
-  @doc """
-  Reads the given configuration file alongside its imports.
-
-  It accepts a list of `imported_paths` that should raise if attempted
-  to be imported again (to avoid recursive imports).
-
-  It returns a tuple with the configuration and the imported paths.
-  """
-  @doc since: "1.9.0"
-  @spec read_imports!(Path.t(), [Path.t()]) :: {keyword, [Path.t()]}
-  def read_imports!(file, imported_paths \\ [])
-      when is_binary(file) and is_list(imported_paths) do
-    Config.__eval__!(file, imported_paths)
-  end
-
-  @doc """
-  Merges two configurations.
-
-  The configurations are merged together with the values in
-  the second one having higher preference than the first in
-  case of conflicts. In case both values are set to keyword
-  lists, it deep merges them.
-
-  ## Examples
-
-      iex> Config.Reader.merge([app: [k: :v1]], [app: [k: :v2]])
-      [app: [k: :v2]]
-
-      iex> Config.Reader.merge([app: [k: [v1: 1, v2: 2]]], [app: [k: [v2: :a, v3: :b]]])
-      [app: [k: [v1: 1, v2: :a, v3: :b]]]
-
-      iex> Config.Reader.merge([app1: []], [app2: []])
-      [app1: [], app2: []]
-
-  """
-  @doc since: "1.9.0"
-  @spec merge(keyword, keyword) :: keyword
-  def merge(config1, config2) when is_list(config1) and is_list(config2) do
-    Config.__merge__(config1, config2)
-  end
-end

lib/elixir/lib/dict.ex

@@ -1,6 +1,6 @@
 defmodule Dict do
   @moduledoc ~S"""
-  Generic API for dictionaries.
+  WARNING: this module is deprecated.
 
   If you need a general dictionary, use the `Map` module.
   If you need to manipulate keyword lists, use `Keyword`.
@@ -9,24 +9,19 @@ defmodule Dict do
   `new` function in the respective modules.
   """
 
-  @moduledoc deprecated: "Use Map or Keyword modules instead"
-
   @type key :: any
   @type value :: any
   @type t :: list | map
 
-  message =
-    "Use the Map module for working with maps or the Keyword module for working with keyword lists"
-
-  @deprecated message
+  # TODO: Deprecate every function by 1.4
   defmacro __using__(_) do
     # Use this import to guarantee proper code expansion
     import Kernel, except: [size: 1]
 
-    quote do
-      message = "Use maps and the Map module instead"
+    %{file: file, line: line} = __CALLER__
+    :elixir_errors.warn(line, file, "the Dict module is deprecated")
 
-      @deprecated message
+    quote do
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -34,7 +29,6 @@ defmodule Dict do
         end
       end
 
-      @deprecated message
       def get_lazy(dict, key, fun) when is_function(fun, 0) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -42,14 +36,12 @@ defmodule Dict do
         end
       end
 
-      @deprecated message
       def get_and_update(dict, key, fun) do
         current_value = get(dict, key)
         {get, new_value} = fun.(current_value)
         {get, put(dict, key, new_value)}
       end
 
-      @deprecated message
       def fetch!(dict, key) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -57,33 +49,28 @@ defmodule Dict do
         end
       end
 
-      @deprecated message
       def has_key?(dict, key) do
-        match?({:ok, _}, fetch(dict, key))
+        match? {:ok, _}, fetch(dict, key)
       end
 
-      @deprecated message
       def put_new(dict, key, value) do
         case has_key?(dict, key) do
-          true -> dict
+          true  -> dict
           false -> put(dict, key, value)
         end
       end
 
-      @deprecated message
       def put_new_lazy(dict, key, fun) when is_function(fun, 0) do
         case has_key?(dict, key) do
-          true -> dict
+          true  -> dict
           false -> put(dict, key, fun.())
         end
       end
 
-      @deprecated message
       def drop(dict, keys) do
         Enum.reduce(keys, dict, &delete(&2, &1))
       end
 
-      @deprecated message
       def take(dict, keys) do
         Enum.reduce(keys, new(), fn key, acc ->
           case fetch(dict, key) do
@@ -93,49 +80,41 @@ defmodule Dict do
         end)
       end
 
-      @deprecated message
       def to_list(dict) do
-        reduce(dict, {:cont, []}, fn kv, acc -> {:cont, [kv | acc]} end)
-        |> elem(1)
-        |> :lists.reverse()
+        reduce(dict, {:cont, []}, fn
+          kv, acc -> {:cont, [kv | acc]}
+        end) |> elem(1) |> :lists.reverse
       end
 
-      @deprecated message
       def keys(dict) do
-        reduce(dict, {:cont, []}, fn {k, _}, acc -> {:cont, [k | acc]} end)
-        |> elem(1)
-        |> :lists.reverse()
+        reduce(dict, {:cont, []}, fn
+          {k, _}, acc -> {:cont, [k | acc]}
+        end) |> elem(1) |> :lists.reverse
       end
 
-      @deprecated message
       def values(dict) do
-        reduce(dict, {:cont, []}, fn {_, v}, acc -> {:cont, [v | acc]} end)
-        |> elem(1)
-        |> :lists.reverse()
+        reduce(dict, {:cont, []}, fn
+          {_, v}, acc -> {:cont, [v | acc]}
+        end) |> elem(1) |> :lists.reverse
       end
 
-      @deprecated message
       def equal?(dict1, dict2) do
         # Use this import to avoid conflicts in the user code
         import Kernel, except: [size: 1]
 
         case size(dict1) == size(dict2) do
-          false ->
-            false
-
-          true ->
-            reduce(dict1, {:cont, true}, fn {k, v}, _acc ->
+          false -> false
+          true  ->
+            reduce(dict1, {:cont, true}, fn({k, v}, _acc) ->
               case fetch(dict2, k) do
                 {:ok, ^v} -> {:cont, true}
                 _ -> {:halt, false}
               end
-            end)
-            |> elem(1)
+            end) |> elem(1)
         end
       end
 
-      @deprecated message
-      def merge(dict1, dict2, fun \\ fn _k, _v1, v2 -> v2 end) do
+      def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
         # Use this import to avoid conflicts in the user code
         import Kernel, except: [size: 1]
 
@@ -147,182 +126,144 @@ defmodule Dict do
           reduce(dict2, {:cont, dict1}, fn {k, v2}, acc ->
             {:cont, update(acc, k, v2, &fun.(k, &1, v2))}
           end)
-        end
-        |> elem(1)
+        end |> elem(1)
       end
 
-      @deprecated message
       def update(dict, key, initial, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
-
           :error ->
             put(dict, key, initial)
         end
       end
 
-      @deprecated message
       def update!(dict, key, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
-
           :error ->
             raise KeyError, key: key, term: dict
         end
       end
 
-      @deprecated message
       def pop(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} ->
             {value, delete(dict, key)}
-
           :error ->
             {default, dict}
         end
       end
 
-      @deprecated message
       def pop_lazy(dict, key, fun) when is_function(fun, 0) do
         case fetch(dict, key) do
           {:ok, value} ->
             {value, delete(dict, key)}
-
           :error ->
             {fun.(), dict}
         end
       end
 
-      @deprecated message
       def split(dict, keys) do
         Enum.reduce(keys, {new(), dict}, fn key, {inc, exc} = acc ->
           case fetch(exc, key) do
             {:ok, value} ->
               {put(inc, key, value), delete(exc, key)}
-
             :error ->
               acc
           end
         end)
       end
 
-      defoverridable merge: 2,
-                     merge: 3,
-                     equal?: 2,
-                     to_list: 1,
-                     keys: 1,
-                     values: 1,
-                     take: 2,
-                     drop: 2,
-                     get: 2,
-                     get: 3,
-                     fetch!: 2,
-                     has_key?: 2,
-                     put_new: 3,
-                     pop: 2,
-                     pop: 3,
-                     split: 2,
-                     update: 4,
-                     update!: 3,
-                     get_and_update: 3,
-                     get_lazy: 3,
-                     pop_lazy: 3,
-                     put_new_lazy: 3
+      defoverridable merge: 2, merge: 3, equal?: 2, to_list: 1, keys: 1,
+                     values: 1, take: 2, drop: 2, get: 2, get: 3, fetch!: 2,
+                     has_key?: 2, put_new: 3, pop: 2, pop: 3, split: 2,
+                     update: 4, update!: 3, get_and_update: 3, get_lazy: 3,
+                     pop_lazy: 3, put_new_lazy: 3
     end
   end
 
   defmacrop target(dict) do
     quote do
       case unquote(dict) do
-        %module{} -> module
-        %{} -> Map
-        dict when is_list(dict) -> Keyword
-        dict -> unsupported_dict(dict)
+        %{__struct__: x} when is_atom(x) ->
+          x
+        %{} ->
+          Map
+        x when is_list(x) ->
+          Keyword
+        x ->
+          unsupported_dict(x)
       end
     end
   end
 
-  @deprecated message
   @spec keys(t) :: [key]
   def keys(dict) do
     target(dict).keys(dict)
   end
 
-  @deprecated message
   @spec values(t) :: [value]
   def values(dict) do
     target(dict).values(dict)
   end
 
-  @deprecated message
   @spec size(t) :: non_neg_integer
   def size(dict) do
     target(dict).size(dict)
   end
 
-  @deprecated message
   @spec has_key?(t, key) :: boolean
   def has_key?(dict, key) do
     target(dict).has_key?(dict, key)
   end
 
-  @deprecated message
   @spec get(t, key, value) :: value
   def get(dict, key, default \\ nil) do
     target(dict).get(dict, key, default)
   end
 
-  @deprecated message
   @spec get_lazy(t, key, (() -> value)) :: value
   def get_lazy(dict, key, fun) do
     target(dict).get_lazy(dict, key, fun)
   end
 
-  @deprecated message
   @spec get_and_update(t, key, (value -> {value, value})) :: {value, t}
   def get_and_update(dict, key, fun) do
     target(dict).get_and_update(dict, key, fun)
   end
 
-  @deprecated message
   @spec fetch(t, key) :: value
   def fetch(dict, key) do
     target(dict).fetch(dict, key)
   end
 
-  @deprecated message
-  @spec fetch!(t, key) :: value
+  @spec fetch!(t, key) :: value | no_return
   def fetch!(dict, key) do
     target(dict).fetch!(dict, key)
   end
 
-  @deprecated message
   @spec put(t, key, value) :: t
   def put(dict, key, val) do
     target(dict).put(dict, key, val)
   end
 
-  @deprecated message
   @spec put_new(t, key, value) :: t
   def put_new(dict, key, val) do
     target(dict).put_new(dict, key, val)
   end
 
-  @deprecated message
   @spec put_new_lazy(t, key, (() -> value)) :: t
   def put_new_lazy(dict, key, fun) do
     target(dict).put_new_lazy(dict, key, fun)
   end
 
-  @deprecated message
   @spec delete(t, key) :: t
   def delete(dict, key) do
     target(dict).delete(dict, key)
   end
 
-  @deprecated message
   @spec merge(t, t) :: t
   def merge(dict1, dict2) do
     target1 = target(dict1)
@@ -331,11 +272,10 @@ defmodule Dict do
     if target1 == target2 do
       target1.merge(dict1, dict2)
     else
-      do_merge(target1, dict1, dict2, fn _k, _v1, v2 -> v2 end)
+      do_merge(target1, dict1, dict2, fn(_k, _v1, v2) -> v2 end)
     end
   end
 
-  @deprecated message
   @spec merge(t, t, (key, value, value -> value)) :: t
   def merge(dict1, dict2, fun) do
     target1 = target(dict1)
@@ -349,61 +289,51 @@ defmodule Dict do
   end
 
   defp do_merge(target1, dict1, dict2, fun) do
-    Enumerable.reduce(dict2, {:cont, dict1}, fn {k, v}, acc ->
-      {:cont, target1.update(acc, k, v, fn other -> fun.(k, other, v) end)}
-    end)
-    |> elem(1)
+    Enumerable.reduce(dict2, {:cont, dict1}, fn({k, v}, acc) ->
+      {:cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end)}
+    end) |> elem(1)
   end
 
-  @deprecated message
   @spec pop(t, key, value) :: {value, t}
   def pop(dict, key, default \\ nil) do
     target(dict).pop(dict, key, default)
   end
 
-  @deprecated message
   @spec pop_lazy(t, key, (() -> value)) :: {value, t}
   def pop_lazy(dict, key, fun) do
     target(dict).pop_lazy(dict, key, fun)
   end
 
-  @deprecated message
   @spec update!(t, key, (value -> value)) :: t
   def update!(dict, key, fun) do
     target(dict).update!(dict, key, fun)
   end
 
-  @deprecated message
   @spec update(t, key, value, (value -> value)) :: t
   def update(dict, key, initial, fun) do
     target(dict).update(dict, key, initial, fun)
   end
 
-  @deprecated message
   @spec split(t, [key]) :: {t, t}
   def split(dict, keys) do
     target(dict).split(dict, keys)
   end
 
-  @deprecated message
   @spec drop(t, [key]) :: t
   def drop(dict, keys) do
     target(dict).drop(dict, keys)
   end
 
-  @deprecated message
   @spec take(t, [key]) :: t
   def take(dict, keys) do
     target(dict).take(dict, keys)
   end
 
-  @deprecated message
   @spec empty(t) :: t
   def empty(dict) do
     target(dict).empty(dict)
   end
 
-  @deprecated message
   @spec equal?(t, t) :: boolean
   def equal?(dict1, dict2) do
     target1 = target(dict1)
@@ -414,20 +344,18 @@ defmodule Dict do
         target1.equal?(dict1, dict2)
 
       target1.size(dict1) == target2.size(dict2) ->
-        Enumerable.reduce(dict2, {:cont, true}, fn {k, v}, _acc ->
+        Enumerable.reduce(dict2, {:cont, true}, fn({k, v}, _acc) ->
           case target1.fetch(dict1, k) do
             {:ok, ^v} -> {:cont, true}
-            _ -> {:halt, false}
+            _         -> {:halt, false}
           end
-        end)
-        |> elem(1)
+        end) |> elem(1)
 
       true ->
         false
     end
   end
 
-  @deprecated message
   @spec to_list(t) :: list
   def to_list(dict) do
     target(dict).to_list(dict)
@@ -435,6 +363,6 @@ defmodule Dict do
 
   @spec unsupported_dict(t) :: no_return
   defp unsupported_dict(dict) do
-    raise ArgumentError, "unsupported dict: #{inspect(dict)}"
+    raise ArgumentError, "unsupported dict: #{inspect dict}"
   end
 end

lib/elixir/lib/file/stat.ex

@@ -12,7 +12,7 @@ defmodule File.Stat do
 
     * `size` - size of file in bytes.
 
-    * `type` - `:device | :directory | :regular | :other | :symlink`; the type of the
+    * `type` - `:device | :directory | :regular | :other`; the type of the
       file.
 
     * `access` - `:read | :write | :read_write | :none`; the current system
@@ -23,7 +23,7 @@ defmodule File.Stat do
     * `mtime` - the last time the file was written.
 
     * `ctime` - the interpretation of this time field depends on the operating
-      system. On Unix-like operating systems, it is the last time the file or the inode was changed.
+      system. On Unix, it is the last time the file or the inode was changed.
       In Windows, it is the time of creation.
 
     * `mode` - the file permissions.
@@ -35,17 +35,17 @@ defmodule File.Stat do
       In Windows, the number indicates a drive as follows: 0 means A:, 1 means
       B:, and so on.
 
-    * `minor_device` - only valid for character devices on Unix-like systems. In all other
+    * `minor_device` - only valid for character devices on Unix. In all other
       cases, this field is zero.
 
-    * `inode` - gives the inode number. On non-Unix-like file systems, this field
+    * `inode` - gives the inode number. On non-Unix file systems, this field
       will be zero.
 
-    * `uid` - indicates the owner of the file. Will be zero for non-Unix-like file
+    * `uid` - indicates the owner of the file. Will be zero for non-Unix file
       systems.
 
     * `gid` - indicates the group that owns the file. Will be zero for
-      non-Unix-like file systems.
+      non-Unix file systems.
 
   The time type returned in `atime`, `mtime`, and `ctime` is dependent on the
   time type set in options. `{:time, type}` where type can be `:local`,
@@ -53,32 +53,16 @@ defmodule File.Stat do
   """
 
   record = Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
-  keys = :lists.map(&elem(&1, 0), record)
-  vals = :lists.map(&{&1, [], nil}, keys)
-  pairs = :lists.zip(keys, vals)
+  keys   = :lists.map(&elem(&1, 0), record)
+  vals   = :lists.map(&{&1, [], nil}, keys)
+  pairs  = :lists.zip(keys, vals)
 
   defstruct keys
-
-  @type t :: %__MODULE__{
-          size: non_neg_integer(),
-          type: :device | :directory | :regular | :other | :symlink,
-          access: :read | :write | :read_write | :none,
-          atime: :calendar.datetime() | integer(),
-          mtime: :calendar.datetime() | integer(),
-          ctime: :calendar.datetime() | integer(),
-          mode: non_neg_integer(),
-          links: non_neg_integer(),
-          major_device: non_neg_integer(),
-          minor_device: non_neg_integer(),
-          inode: non_neg_integer(),
-          uid: non_neg_integer(),
-          gid: non_neg_integer()
-        }
+  @type t :: %__MODULE__{}
 
   @doc """
   Converts a `File.Stat` struct to a `:file_info` record.
   """
-  @spec to_record(t()) :: :file.file_info()
   def to_record(%File.Stat{unquote_splicing(pairs)}) do
     {:file_info, unquote_splicing(vals)}
   end
@@ -86,9 +70,7 @@ defmodule File.Stat do
   @doc """
   Converts a `:file_info` record into a `File.Stat`.
   """
-  @spec from_record(:file.file_info()) :: t()
   def from_record(file_info)
-
   def from_record({:file_info, unquote_splicing(vals)}) do
     %File.Stat{unquote_splicing(pairs)}
   end

lib/elixir/lib/file/stream.ex

@@ -7,7 +7,7 @@ defmodule File.Stream do
     * `path`          - the file path
     * `modes`         - the file modes
     * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given number of bytes
+    * `line_or_bytes` - if reading should read lines or a given amount of bytes
 
   """
 
@@ -22,12 +22,11 @@ defmodule File.Stream do
     modes =
       case raw do
         true ->
-          case :lists.keyfind(:read_ahead, 1, modes) do
-            {:read_ahead, false} -> [:raw | :lists.keydelete(:read_ahead, 1, modes)]
-            {:read_ahead, _} -> [:raw | modes]
-            false -> [:raw, :read_ahead | modes]
+          if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
+            [:raw | modes]
+          else
+            [:raw, :read_ahead | modes]
           end
-
         false ->
           modes
       end
@@ -37,12 +36,11 @@ defmodule File.Stream do
 
   defimpl Collectable do
     def into(%{path: path, modes: modes, raw: raw} = stream) do
-      modes = for mode <- modes, mode not in [:read], do: mode
+      modes = for mode <- modes, not mode in [:read], do: mode
 
       case :file.open(path, [:write | modes]) do
         {:ok, device} ->
           {:ok, into(device, stream, raw)}
-
         {:error, reason} ->
           raise File.Error, reason: reason, action: "stream", path: path
       end
@@ -52,16 +50,14 @@ defmodule File.Stream do
       fn
         :ok, {:cont, x} ->
           case raw do
-            true -> IO.binwrite(device, x)
+            true  -> IO.binwrite(device, x)
             false -> IO.write(device, x)
           end
-
         :ok, :done ->
           # If delayed_write option is used and the last write failed will
           # MatchError here as {:error, _} is returned.
           :ok = :file.close(device)
           stream
-
         :ok, :halt ->
           # If delayed_write option is used and the last write failed will
           # MatchError here as {:error, _} is returned.
@@ -71,55 +67,27 @@ defmodule File.Stream do
   end
 
   defimpl Enumerable do
-    @read_ahead_size 64 * 1024
-
     def reduce(%{path: path, modes: modes, line_or_bytes: line_or_bytes, raw: raw}, acc, fun) do
-      start_fun = fn ->
-        case :file.open(path, read_modes(modes)) do
-          {:ok, device} ->
-            if :trim_bom in modes, do: trim_bom(device, raw) |> elem(0), else: device
+      modes = for mode <- modes, not mode in [:write, :append], do: mode
 
-          {:error, reason} ->
-            raise File.Error, reason: reason, action: "stream", path: path
+      start_fun =
+        fn ->
+          case :file.open(path, modes) do
+            {:ok, device}    -> device
+            {:error, reason} ->
+              raise File.Error, reason: reason, action: "stream", path: path
+          end
         end
-      end
 
       next_fun =
         case raw do
-          true -> &IO.each_binstream(&1, line_or_bytes)
+          true  -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
 
       Stream.resource(start_fun, next_fun, &:file.close/1).(acc, fun)
     end
 
-    def count(%{path: path, modes: modes, line_or_bytes: :line} = stream) do
-      pattern = :binary.compile_pattern("\n")
-      counter = &count_lines(&1, path, pattern, read_function(stream), 0)
-
-      case File.open(path, read_modes(modes), counter) do
-        {:ok, count} ->
-          {:ok, count}
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    def count(%{path: path, line_or_bytes: bytes, raw: true, modes: modes}) do
-      case File.stat(path) do
-        {:ok, %{size: 0}} ->
-          {:error, __MODULE__}
-
-        {:ok, %{size: size}} ->
-          remainder = if rem(size, bytes) == 0, do: 0, else: 1
-          {:ok, div(size, bytes) + remainder - count_raw_bom(path, modes)}
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
     def count(_stream) do
       {:error, __MODULE__}
     end
@@ -127,64 +95,5 @@ defmodule File.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
-
-    def slice(_stream) do
-      {:error, __MODULE__}
-    end
-
-    defp count_raw_bom(path, modes) do
-      if :trim_bom in modes do
-        File.open!(path, read_modes(modes), &(&1 |> trim_bom(true) |> elem(1)))
-      else
-        0
-      end
-    end
-
-    defp trim_bom(device, true) do
-      bom_length = device |> IO.binread(4) |> bom_length()
-      {:ok, new_pos} = :file.position(device, bom_length)
-      {device, new_pos}
-    end
-
-    defp trim_bom(device, false) do
-      # Or we read the bom in the correct amount or it isn't there
-      case bom_length(IO.read(device, 1)) do
-        0 ->
-          {:ok, _} = :file.position(device, 0)
-          {device, 0}
-
-        _ ->
-          {device, 1}
-      end
-    end
-
-    defp bom_length(<<239, 187, 191, _rest::binary>>), do: 3
-    defp bom_length(<<254, 255, _rest::binary>>), do: 2
-    defp bom_length(<<255, 254, _rest::binary>>), do: 2
-    defp bom_length(<<0, 0, 254, 255, _rest::binary>>), do: 4
-    defp bom_length(<<254, 255, 0, 0, _rest::binary>>), do: 4
-    defp bom_length(_binary), do: 0
-
-    defp read_modes(modes) do
-      for mode <- modes, mode not in [:write, :append, :trim_bom], do: mode
-    end
-
-    defp count_lines(device, path, pattern, read, count) do
-      case read.(device) do
-        data when is_binary(data) ->
-          count_lines(device, path, pattern, read, count + count_lines(data, pattern))
-
-        :eof ->
-          count
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    defp count_lines(data, pattern), do: length(:binary.matches(data, pattern))
-
-    defp read_function(%{raw: true}), do: &IO.binread(&1, @read_ahead_size)
-    defp read_function(%{raw: false}), do: &IO.read(&1, @read_ahead_size)
   end
 end

lib/elixir/lib/float.ex

@@ -2,49 +2,12 @@ import Kernel, except: [round: 1]
 
 defmodule Float do
   @moduledoc """
-  Functions for working with floating-point numbers.
-
-  ## Kernel functions
-
-  There are functions related to floating-point numbers on the `Kernel` module
-  too. Here is a list of them:
-
-    * `Kernel.round/1`: rounds a number to the nearest integer.
-    * `Kernel.trunc/1`: returns the integer part of a number.
-
-  ## Known issues
-
-  There are some very well known problems with floating-point numbers
-  and arithmetics due to the fact most decimal fractions cannot be
-  represented by a floating-point binary and most operations are not exact,
-  but operate on approximations. Those issues are not specific
-  to Elixir, they are a property of floating point representation itself.
-
-  For example, the numbers 0.1 and 0.01 are two of them, what means the result
-  of squaring 0.1 does not give 0.01 neither the closest representable. Here is
-  what happens in this case:
-
-    * The closest representable number to 0.1 is 0.1000000014
-    * The closest representable number to 0.01 is 0.0099999997
-    * Doing 0.1 * 0.1 should return 0.01, but because 0.1 is actually 0.1000000014,
-      the result is 0.010000000000000002, and because this is not the closest
-      representable number to 0.01, you'll get the wrong result for this operation
-
-  There are also other known problems like flooring or rounding numbers. See
-  `round/2` and `floor/2` for more details about them.
-
-  To learn more about floating-point arithmetic visit:
-
-    * [0.30000000000000004.com](http://0.30000000000000004.com/)
-    * [What Every Programmer Should Know About Floating-Point Arithmetic](https://floating-point-gui.de/)
-
+  Functions for working with floating point numbers.
   """
 
   import Bitwise
 
-  @power_of_2_to_52 4_503_599_627_370_496
-  @precision_range 0..15
-  @type precision_range :: 0..15
+  @power_of_2_to_52 4503599627370496
 
   @doc """
   Parses a binary into a float.
@@ -88,44 +51,38 @@ defmodule Float do
     parse_unsigned(binary)
   end
 
-  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9,
-    do: parse_unsigned(rest, false, false, <<digit>>)
+  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9, do:
+    parse_unsigned(rest, false, false, <<digit>>)
 
-  defp parse_unsigned(binary) when is_binary(binary), do: :error
+  defp parse_unsigned(binary) when is_binary(binary), do:
+    :error
 
-  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9,
-    do: parse_unsigned(rest, dot?, e?, <<acc::binary, digit>>)
+  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9, do:
+    parse_unsigned(rest, dot?, e?, <<acc::binary, digit>>)
 
-  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9,
-    do: parse_unsigned(rest, true, false, <<acc::binary, ?., digit>>)
+  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9, do:
+    parse_unsigned(rest, true, false, <<acc::binary, ?., digit>>)
 
-  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc)
-       when exp_marker in 'eE' and digit in ?0..?9,
-       do: parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, digit>>)
+  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and  digit in ?0..?9, do:
+    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, digit>>)
 
-  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc)
-       when exp_marker in 'eE' and sign in '-+' and digit in ?0..?9,
-       do: parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, sign, digit>>)
+  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and sign in '-+' and digit in ?0..?9, do:
+    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, sign, digit>>)
 
-  defp parse_unsigned(rest, dot?, _e?, acc),
-    do: {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
+  defp parse_unsigned(rest, dot?, _e?, acc), do:
+    {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
 
-  defp add_dot(acc, true), do: acc
+  defp add_dot(acc, true),  do: acc
   defp add_dot(acc, false), do: acc <> ".0"
 
   @doc """
-  Rounds a float to the largest number less than or equal to `num`.
+  Rounds a float to the largest integer less than or equal to `num`.
 
-  `floor/2` also accepts a precision to round a floating-point value down
+  `floor/2` also accepts a precision to round a floating point value down
   to an arbitrary number of fractional digits (between 0 and 15).
   The operation is performed on the binary floating point, without a
   conversion to decimal.
 
-  This function always returns a float. `Kernel.trunc/1` may be used instead to
-  truncate the result to an integer afterwards.
-
-  ## Known issues
-
   The behaviour of `floor/2` for floats can be surprising. For example:
 
       iex> Float.floor(12.52, 2)
@@ -136,6 +93,9 @@ defmodule Float do
   and therefore the number above is internally represented as 12.51999999,
   which explains the behaviour above.
 
+  This function always returns a float. `Kernel.trunc/1` may be used instead to
+  truncate the result to an integer afterwards.
+
   ## Examples
 
       iex> Float.floor(34.25)
@@ -146,25 +106,15 @@ defmodule Float do
       34.25
 
   """
-  @spec floor(float, precision_range) :: float
-  def floor(number, precision \\ 0)
-
-  def floor(number, 0) when is_float(number) do
-    :math.floor(number)
-  end
-
-  def floor(number, precision) when is_float(number) and precision in @precision_range do
+  @spec floor(float, 0..15) :: float
+  def floor(number, precision \\ 0) when is_float(number) and precision in 0..15 do
     round(number, precision, :floor)
   end
 
-  def floor(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
   @doc """
   Rounds a float to the smallest integer greater than or equal to `num`.
 
-  `ceil/2` also accepts a precision to round a floating-point value down
+  `ceil/2` also accepts a precision to round a floating point value down
   to an arbitrary number of fractional digits (between 0 and 15).
 
   The operation is performed on the binary floating point, without a
@@ -193,23 +143,13 @@ defmodule Float do
       34.26
 
   """
-  @spec ceil(float, precision_range) :: float
-  def ceil(number, precision \\ 0)
-
-  def ceil(number, 0) when is_float(number) do
-    :math.ceil(number)
-  end
-
-  def ceil(number, precision) when is_float(number) and precision in @precision_range do
+  @spec ceil(float, 0..15) :: float
+  def ceil(number, precision \\ 0) when is_float(number) and precision in 0..15 do
     round(number, precision, :ceil)
   end
 
-  def ceil(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
   @doc """
-  Rounds a floating-point value to an arbitrary number of fractional
+  Rounds a floating point value to an arbitrary number of fractional
   digits (between 0 and 15).
 
   The rounding direction always ties to half up. The operation is
@@ -219,8 +159,6 @@ defmodule Float do
   `Kernel.round/1` if you want a function that accepts both floats
   and integers and always returns an integer.
 
-  ## Known issues
-
   The behaviour of `round/2` for floats can be surprising. For example:
 
       iex> Float.round(5.5675, 3)
@@ -250,42 +188,33 @@ defmodule Float do
       12.341444444444441
 
   """
-  @spec round(float, precision_range) :: float
+  @spec round(float, 0..15) :: float
+
   # This implementation is slow since it relies on big integers.
   # Faster implementations are available on more recent papers
   # and could be implemented in the future.
-  def round(float, precision \\ 0)
-
-  def round(float, 0) when is_float(float) do
-    float |> :erlang.round() |> :erlang.float()
-  end
-
-  def round(float, precision) when is_float(float) and precision in @precision_range do
+  def round(float, precision \\ 0) when is_float(float) and precision in 0..15 do
     round(float, precision, :half_up)
   end
 
-  def round(float, precision) when is_float(float) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
-  defp round(0.0, _precision, _rounding), do: 0.0
-
   defp round(float, precision, rounding) do
     <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
-    {num, count, _} = decompose(significant, 1)
+    {num, count, _} = decompose(significant)
     count = count - exp + 1023
 
     cond do
-      # Precision beyond 15 digits
-      count >= 104 ->
+      count <= 0 or  # There is no decimal precision
+      (0 == exp and <<0::52>> == significant) -> #zero or minus zero
+        float
+
+      count >= 104 -> # Precision beyond 15 digits
         case rounding do
           :ceil when sign === 0 -> 1 / power_of_10(precision)
           :floor when sign === 1 -> -1 / power_of_10(precision)
           _ -> 0.0
         end
 
-      # We are asking more precision than we have
-      count <= precision ->
+      count <= precision -> # We are asking more precision than we have
         float
 
       true ->
@@ -305,18 +234,16 @@ defmodule Float do
         num = rounding(rounding, sign, num, div)
 
         # Convert back to float without loss
-        # https://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/
+        # http://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/
         den = power_of_10(precision)
         boundary = den <<< 52
 
         cond do
           num == 0 ->
             0.0
-
           num >= boundary ->
             {den, exp} = scale_down(num, boundary, 52)
             decimal_to_float(sign, num, den, exp)
-
           true ->
             {num, exp} = scale_up(num, boundary, 52)
             decimal_to_float(sign, num, den, exp)
@@ -329,7 +256,6 @@ defmodule Float do
 
   defp scale_down(num, den, exp) do
     new_den = den <<< 1
-
     if num < new_den do
       {den >>> 52, exp}
     else
@@ -350,31 +276,29 @@ defmodule Float do
       end
 
     tmp = tmp - @power_of_2_to_52
-    <<tmp::float>> = <<sign::1, exp + 1023::11, tmp::52>>
+    <<tmp::float>> = <<sign::1, (exp + 1023)::11, tmp::52>>
     tmp
   end
 
   defp rounding(:floor, 1, _num, div), do: div + 1
   defp rounding(:ceil, 0, _num, div), do: div + 1
-
   defp rounding(:half_up, _sign, num, div) do
     case rem(num, 10) do
       rem when rem < 5 -> div
       rem when rem >= 5 -> div + 1
     end
   end
-
   defp rounding(_, _, _, div), do: div
 
-  Enum.reduce(0..104, 1, fn x, acc ->
+  Enum.reduce 0..104, 1, fn x, acc ->
     defp power_of_10(unquote(x)), do: unquote(acc)
     acc * 10
-  end)
+  end
 
-  Enum.reduce(0..104, 1, fn x, acc ->
+  Enum.reduce 0..104, 1, fn x, acc ->
     defp power_of_5(unquote(x)), do: unquote(acc)
     acc * 5
-  end)
+  end
 
   @doc """
   Returns a pair of integers whose ratio is exactly equal
@@ -382,8 +306,6 @@ defmodule Float do
 
   ## Examples
 
-      iex> Float.ratio(0.0)
-      {0, 1}
       iex> Float.ratio(3.14)
       {7070651414971679, 2251799813685248}
       iex> Float.ratio(-3.14)
@@ -398,55 +320,40 @@ defmodule Float do
       {-16, 1}
 
   """
-  @doc since: "1.4.0"
-  @spec ratio(float) :: {integer, pos_integer}
-  def ratio(0.0), do: {0, 1}
-
   def ratio(float) when is_float(float) do
-    case <<float::float>> do
-      <<sign::1, 0::11, significant::52-bitstring>> ->
-        {num, _, den} = decompose(significant, 0)
-        {sign(sign, num), shift_left(den, 1022)}
-
-      <<sign::1, exp::11, significant::52-bitstring>> ->
-        {num, _, den} = decompose(significant, 1)
-        num = sign(sign, num)
-
-        case exp - 1023 do
-          exp when exp > 0 ->
-            {den, exp} = shift_right(den, exp)
-            {shift_left(num, exp), den}
-
-          exp when exp < 0 ->
-            {num, shift_left(den, -exp)}
-
-          0 ->
-            {num, den}
-        end
+    <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
+    {num, _, den} = decompose(significant)
+    num = sign(sign, num)
+    case exp - 1023 do
+      exp when exp > 0 ->
+        {den, exp} = shift_right(den, exp)
+        {shift_left(num, exp), den}
+      exp when exp < 0 ->
+        {num, shift_left(den, -exp)}
+      0 ->
+        {num, den}
     end
   end
 
-  defp decompose(significant, initial) do
-    decompose(significant, 1, 0, 2, 1, initial)
+  defp decompose(significant) do
+    decompose(significant, 1, 0, 2, 1, 1)
   end
 
   defp decompose(<<1::1, bits::bitstring>>, count, last_count, power, _last_power, acc) do
     decompose(bits, count + 1, count, power <<< 1, power, shift_left(acc, count - last_count) + 1)
   end
-
   defp decompose(<<0::1, bits::bitstring>>, count, last_count, power, last_power, acc) do
     decompose(bits, count + 1, last_count, power <<< 1, last_power, acc)
   end
-
   defp decompose(<<>>, _count, last_count, _power, last_power, acc) do
     {acc, last_count, last_power}
   end
 
-  @compile {:inline, sign: 2, shift_left: 2}
   defp sign(0, num), do: num
   defp sign(1, num), do: -num
 
-  defp shift_left(num, times), do: num <<< times
+  defp shift_left(num, 0), do: num
+  defp shift_left(num, times), do: shift_left(num <<< 1, times - 1)
 
   defp shift_right(num, 0), do: {num, 0}
   defp shift_right(1, times), do: {1, times}
@@ -487,33 +394,29 @@ defmodule Float do
       "7.0"
 
   """
-  @spec to_string(float) :: String.t()
+  @spec to_string(float) :: String.t
   def to_string(float) when is_float(float) do
     IO.iodata_to_binary(:io_lib_format.fwrite_g(float))
   end
 
+  # TODO: Deprecate by v1.5
   @doc false
-  @deprecated "Use Float.to_charlist/1 instead"
   def to_char_list(float), do: Float.to_charlist(float)
 
   @doc false
-  @deprecated "Use :erlang.float_to_list/2 instead"
   def to_char_list(float, options) do
+    IO.warn "Float.to_char_list/2 is deprecated, use :erlang.float_to_list/2 instead"
     :erlang.float_to_list(float, expand_compact(options))
   end
 
   @doc false
-  @deprecated "Use :erlang.float_to_binary/2 instead"
   def to_string(float, options) do
+    IO.warn "Float.to_string/2 is deprecated, use :erlang.float_to_binary/2 instead"
     :erlang.float_to_binary(float, expand_compact(options))
   end
 
-  defp invalid_precision_message(precision) do
-    "precision #{precision} is out of valid range of #{inspect(@precision_range)}"
-  end
-
   defp expand_compact([{:compact, false} | t]), do: expand_compact(t)
-  defp expand_compact([{:compact, true} | t]), do: [:compact | expand_compact(t)]
-  defp expand_compact([h | t]), do: [h | expand_compact(t)]
-  defp expand_compact([]), do: []
+  defp expand_compact([{:compact, true} | t]),  do: [:compact | expand_compact(t)]
+  defp expand_compact([h | t]),                 do: [h | expand_compact(t)]
+  defp expand_compact([]),                      do: []
 end

lib/elixir/lib/function.ex

@@ -1,192 +0,0 @@
-defmodule Function do
-  @moduledoc """
-  A set of functions for working with functions.
-
-  Anonymous functions are typically created by using `fn`:
-
-      iex> add = fn a, b -> a + b end
-      iex> add.(1, 2)
-      3
-
-  It is also possible to capture module functions and pass them around
-  as if they were anonymous functions by using the capture operator `&/1`:
-
-      iex> add = &Kernel.+/2
-      iex> add.(1, 2)
-      3
-
-      iex> length = &String.length/1
-      iex> length.("hello")
-      5
-
-  It is also possible to capture a definition in the current module by
-  skipping the module prefix, such as `&my_fun/2`.
-
-  The capture operator can also be used to create anonymous functions
-  that expect at least one argument:
-
-      iex> add = &(&1 + &2)
-      iex> add.(1, 2)
-      3
-
-  In such cases, using the capture operator is no different than using `fn`.
-
-  We say that functions that point to definitions residing in modules, such
-  as `&String.length/1`, are **external** functions. All other functions are
-  **local** and they are always bound to the file or module that defined them.
-
-  Besides the functions in this module to work with functions, `Kernel` also
-  has an `apply/2` function that invokes a function with a dynamic number of
-  arguments, as well as `is_function/1` and `is_function/2`, to check
-  respectively if a given value is a function or a function of a given arity.
-  """
-
-  @type information ::
-          :arity
-          | :env
-          | :index
-          | :module
-          | :name
-          | :new_index
-          | :new_uniq
-          | :pid
-          | :type
-          | :uniq
-
-  @doc """
-  Captures the given function.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> Function.capture(String, :length, 1)
-      &String.length/1
-
-  """
-  @doc since: "1.7.0"
-  @spec capture(module, atom, arity) :: fun
-  def capture(module, function_name, arity) do
-    :erlang.make_fun(module, function_name, arity)
-  end
-
-  @doc """
-  Returns a keyword list with information about a function.
-
-  The returned keys (with the corresponding possible values) for
-  all types of functions (local and external) are the following:
-
-    * `:type` - `:local` (for anonymous functions) or `:external` (for
-      named functions).
-
-    * `:module` - an atom which is the module where the function is defined when
-    anonymous or the module which the function refers to when it's a named function.
-
-    * `:arity` - (integer) the number of arguments the function is to be called with.
-
-    * `:name` - (atom) the name of the function.
-
-    * `:env` - a list of the environment or free variables. For named
-      functions, the returned list is always empty.
-
-  When `fun` is an anonymous function (that is, the type is `:local`), the following
-  additional keys are returned:
-
-    * `:pid` - PID of the process that originally created the function.
-
-    * `:index` - (integer) an index into the module function table.
-
-    * `:new_index` - (integer) an index into the module function table.
-
-    * `:new_uniq` - (binary) a unique value for this function. It's
-      calculated from the compiled code for the entire module.
-
-    * `:uniq` - (integer) a unique value for this function. This integer is
-      calculated from the compiled code for the entire module.
-
-  **Note**: this function must be used only for debugging purposes.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> fun = fn x -> x end
-      iex> info = Function.info(fun)
-      iex> Keyword.get(info, :arity)
-      1
-      iex> Keyword.get(info, :type)
-      :local
-
-      iex> fun = &String.length/1
-      iex> info = Function.info(fun)
-      iex> Keyword.get(info, :type)
-      :external
-      iex> Keyword.get(info, :name)
-      :length
-
-  """
-  @doc since: "1.7.0"
-  @spec info(fun) :: [{information, term}]
-  def info(fun), do: :erlang.fun_info(fun)
-
-  @doc """
-  Returns a specific information about the function.
-
-  The returned information is a two-element tuple in the shape of
-  `{info, value}`.
-
-  For any function, the information asked for can be any of the atoms
-  `:module`, `:name`, `:arity`, `:env`, or `:type`.
-
-  For anonymous functions, there is also information about any of the
-  atoms `:index`, `:new_index`, `:new_uniq`, `:uniq`, and `:pid`.
-  For a named function, the value of any of these items is always the
-  atom `:undefined`.
-
-  For more information on each of the possible returned values, see
-  `info/1`.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> f = fn x -> x end
-      iex> Function.info(f, :arity)
-      {:arity, 1}
-      iex> Function.info(f, :type)
-      {:type, :local}
-
-      iex> fun = &String.length/1
-      iex> Function.info(fun, :name)
-      {:name, :length}
-      iex> Function.info(fun, :pid)
-      {:pid, :undefined}
-
-  """
-  @doc since: "1.7.0"
-  @spec info(fun, item) :: {item, term} when item: information
-  def info(fun, item), do: :erlang.fun_info(fun, item)
-
-  @doc """
-  Returns its input `value`. This function can be passed as an anonymous function
-  to transformation functions.
-
-  ## Examples
-
-      iex> Function.identity("Hello world!")
-      "Hello world!"
-
-      iex> 'abcdaabccc' |> Enum.sort() |> Enum.chunk_by(&Function.identity/1)
-      ['aaa', 'bb', 'cccc', 'd']
-
-      iex> Enum.group_by('abracadabra', &Function.identity/1)
-      %{97 => 'aaaaa', 98 => 'bb', 99 => 'c', 100 => 'd', 114 => 'rr'}
-
-      iex> Enum.map([1, 2, 3, 4], &Function.identity/1)
-      [1, 2, 3, 4]
-
-  """
-  @doc since: "1.10.0"
-  @spec identity(value) :: value when value: var
-  def identity(value), do: value
-end

lib/elixir/lib/gen_event/stream.ex

@@ -2,7 +2,9 @@ defmodule GenEvent.Stream do
   @moduledoc false
   defstruct manager: nil, timeout: :infinity
 
-  @type t :: %__MODULE__{manager: GenEvent.manager(), timeout: timeout}
+  @type t :: %__MODULE__{
+               manager: GenEvent.manager,
+               timeout: timeout}
 
   @doc false
   def init({_pid, _ref} = state) do
@@ -22,7 +24,6 @@ defmodule GenEvent.Stream do
   def handle_call(msg, _state) do
     # We do this to trick Dialyzer to not complain about non-local returns.
     reason = {:bad_call, msg}
-
     case :erlang.phash2(1, 1) do
       0 -> exit(reason)
       1 -> {:remove_handler, reason}
@@ -47,7 +48,7 @@ end
 
 defimpl Enumerable, for: GenEvent.Stream do
   def reduce(stream, acc, fun) do
-    start_fun = fn -> start(stream) end
+    start_fun = fn() -> start(stream) end
     next_fun = &next(stream, &1)
     stop_fun = &stop(stream, &1)
     Stream.resource(start_fun, next_fun, stop_fun).(acc, wrap_reducer(fun))
@@ -61,33 +62,26 @@ defimpl Enumerable, for: GenEvent.Stream do
     {:error, __MODULE__}
   end
 
-  def slice(_stream) do
-    {:error, __MODULE__}
-  end
-
   defp wrap_reducer(fun) do
     fn
       {:ack, manager, ref, event}, acc ->
-        send(manager, {ref, :ok})
+        send manager, {ref, :ok}
         fun.(event, acc)
-
       {:async, _manager, _ref, event}, acc ->
         fun.(event, acc)
-
       {:sync, manager, ref, event}, acc ->
         try do
           fun.(event, acc)
         after
-          send(manager, {ref, :ok})
+          send manager, {ref, :ok}
         end
     end
   end
 
   defp start(%{manager: manager} = stream) do
     try do
-      {:ok, {pid, ref}} =
-        :gen.call(manager, self(), {:add_process_handler, self(), self()}, :infinity)
-
+      {:ok, {pid, ref}} = :gen.call(manager, self(),
+                                    {:add_process_handler, self(), self()}, :infinity)
       mon_ref = Process.monitor(pid)
       {pid, ref, mon_ref}
     catch
@@ -135,7 +129,6 @@ defimpl Enumerable, for: GenEvent.Stream do
     case wait_for_handler_removal(pid, ref, mon_ref) do
       :ok ->
         flush_events(ref)
-
       {:error, reason} ->
         exit({reason, {__MODULE__, :stop, [stream, acc]}})
     end
@@ -144,7 +137,7 @@ defimpl Enumerable, for: GenEvent.Stream do
   # If we reach this branch, the handler was not removed yet,
   # so we trigger a request for doing so.
   defp stop(stream, {pid, ref, _} = acc) do
-    _ = :gen_event.delete_handler(pid, {pid, ref}, :shutdown)
+    _ = GenEvent.remove_handler(pid, {pid, ref}, :shutdown)
     stop(stream, {:removed, acc})
   end
 
@@ -153,7 +146,6 @@ defimpl Enumerable, for: GenEvent.Stream do
       {:gen_event_EXIT, {^pid, ^ref}, _reason} ->
         Process.demonitor(mon_ref, [:flush])
         :ok
-
       {:DOWN, ^mon_ref, _, _, reason} ->
         {:error, reason}
     end
@@ -161,8 +153,7 @@ defimpl Enumerable, for: GenEvent.Stream do
 
   defp flush_events(ref) do
     receive do
-      {_from, {_pid, ^ref}, {notify, _event}}
-      when notify in [:notify, :ack_notify, :sync_notify] ->
+      {_from, {_pid, ^ref}, {notify, _event}} when notify in [:notify, :ack_notify, :sync_notify] ->
         flush_events(ref)
     after
       0 -> :ok

lib/elixir/lib/hash_dict.ex

@@ -1,11 +1,11 @@
 defmodule HashDict do
   @moduledoc """
-  Tuple-based HashDict implementation.
+  WARNING: this module is deprecated.
 
-  This module is deprecated. Use the `Map` module instead.
+  Use the `Map` module instead.
   """
 
-  @moduledoc deprecated: "Use Map instead"
+  # TODO: Deprecate every function by 1.4
 
   use Dict
 
@@ -22,70 +22,58 @@ defmodule HashDict do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
-  message = "Use maps and the Map module instead"
-
   @doc """
   Creates a new empty dict.
   """
-  @spec new :: Dict.t()
-  @deprecated message
+  @spec new :: Dict.t
   def new do
     %HashDict{}
   end
 
-  @deprecated message
   def put(%HashDict{root: root, size: size}, key, value) do
     {root, counter} = do_put(root, key, value, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
-  @deprecated message
   def update!(%HashDict{root: root, size: size} = dict, key, fun) when is_function(fun, 1) do
-    {root, counter} =
-      do_update(root, key, fn -> raise KeyError, key: key, term: dict end, fun, key_hash(key))
-
+    {root, counter} = do_update(root, key, fn -> raise KeyError, key: key, term: dict end,
+                                fun, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
-  @deprecated message
   def update(%HashDict{root: root, size: size}, key, initial, fun) when is_function(fun, 1) do
     {root, counter} = do_update(root, key, fn -> initial end, fun, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
-  @deprecated message
   def fetch(%HashDict{root: root}, key) do
     do_fetch(root, key, key_hash(key))
   end
 
-  @deprecated message
   def delete(dict, key) do
     case dict_delete(dict, key) do
       {dict, _value} -> dict
-      :error -> dict
+      :error         -> dict
     end
   end
 
-  @deprecated message
   def pop(dict, key, default \\ nil) do
     case dict_delete(dict, key) do
       {dict, value} -> {value, dict}
-      :error -> {default, dict}
+      :error        -> {default, dict}
     end
   end
 
-  @deprecated message
   def size(%HashDict{size: size}) do
     size
   end
 
   @doc false
-  @deprecated message
   def reduce(%HashDict{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc} -> {:halted, acc}
-      {:cont, acc} -> {:done, acc}
+      {:halt, acc}    -> {:halted, acc}
+      {:cont, acc}    -> {:done, acc}
     end)
   end
 
@@ -95,7 +83,7 @@ defmodule HashDict do
   def dict_delete(%HashDict{root: root, size: size}, key) do
     case do_delete(root, key, key_hash(key)) do
       {root, value} -> {%HashDict{root: root, size: size - 1}, value}
-      :error -> :error
+      :error        -> :error
     end
   end
 
@@ -103,32 +91,26 @@ defmodule HashDict do
 
   defp do_fetch(node, key, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
-      [^key | v] -> {:ok, v}
+      [^key | v]   -> {:ok, v}
       {^key, v, _} -> {:ok, v}
-      {_, _, n} -> do_fetch(n, key, key_shift(hash))
-      _ -> :error
+      {_, _, n}    -> do_fetch(n, key, key_shift(hash))
+      _            -> :error
     end
   end
 
   defp do_put(node, key, value, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [key | value]), 1}
-
       [^key | _] ->
         {put_elem(node, index, [key | value]), 0}
-
       [k | v] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [key | value])
         {put_elem(node, index, {k, v, n}), 1}
-
       {^key, _, n} ->
         {put_elem(node, index, {key, value, n}), 0}
-
       {k, v, n} ->
         {n, counter} = do_put(n, key, value, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
@@ -137,21 +119,16 @@ defmodule HashDict do
 
   defp do_update(node, key, initial, fun, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [key | initial.()]), 1}
-
       [^key | value] ->
         {put_elem(node, index, [key | fun.(value)]), 0}
-
       [k | v] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [key | initial.()])
         {put_elem(node, index, {k, v, n}), 1}
-
       {^key, value, n} ->
         {put_elem(node, index, {key, fun.(value), n}), 0}
-
       {k, v, n} ->
         {n, counter} = do_update(n, key, initial, fun, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
@@ -160,35 +137,28 @@ defmodule HashDict do
 
   defp do_delete(node, key, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         :error
-
       [^key | value] ->
         {put_elem(node, index, []), value}
-
       [_ | _] ->
         :error
-
       {^key, value, n} ->
         {put_elem(node, index, do_compact_node(n)), value}
-
       {k, v, n} ->
         case do_delete(n, key, key_shift(hash)) do
           {@node_template, value} ->
             {put_elem(node, index, [k | v]), value}
-
           {n, value} ->
             {put_elem(node, index, {k, v, n}), value}
-
           :error ->
             :error
         end
     end
   end
 
-  Enum.each(0..(@node_size - 1), fn index ->
+  Enum.each 0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
         [k | v] ->
@@ -196,12 +166,11 @@ defmodule HashDict do
             @node_template -> [k | v]
             n -> {k, v, n}
           end
-
         {k, v, n} ->
           {k, v, put_elem(node, unquote(index), do_compact_node(n))}
       end
     end
-  end)
+  end
 
   ## Dict reduce
 
@@ -226,12 +195,7 @@ defmodule HashDict do
   end
 
   defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(
-      :erlang.element(count, node),
-      acc,
-      fun,
-      &do_reduce(node, &1, fun, count - 1, next)
-    )
+    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
   end
 
   defp do_reduce(_node, acc, _fun, 0, next) do
@@ -256,45 +220,19 @@ defmodule HashDict do
 end
 
 defimpl Enumerable, for: HashDict do
-  def reduce(dict, acc, fun) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    module.reduce(dict, acc, fun)
-  end
-
-  def member?(dict, {key, value}) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {:ok, match?({:ok, ^value}, module.fetch(dict, key))}
-  end
-
-  def member?(_dict, _) do
-    {:ok, false}
-  end
-
-  def count(dict) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {:ok, module.size(dict)}
-  end
-
-  def slice(_dict) do
-    {:error, __MODULE__}
-  end
+  def reduce(dict, acc, fun),  do: HashDict.reduce(dict, acc, fun)
+  def member?(dict, {k, v}), do: {:ok, match?({:ok, ^v}, HashDict.fetch(dict, k))}
+  def member?(_dict, _),       do: {:ok, false}
+  def count(dict),             do: {:ok, HashDict.size(dict)}
 end
 
 defimpl Collectable, for: HashDict do
   def into(original) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-
-    collector_fun = fn
-      dict, {:cont, {key, value}} -> module.put(dict, key, value)
+    {original, fn
+      dict, {:cont, {k, v}} -> HashDict.put(dict, k, v)
       dict, :done -> dict
       _, :halt -> :ok
-    end
-
-    {original, collector_fun}
+    end}
   end
 end
 
@@ -302,8 +240,6 @@ defimpl Inspect, for: HashDict do
   import Inspect.Algebra
 
   def inspect(dict, opts) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    concat(["#HashDict<", Inspect.List.inspect(module.to_list(dict), opts), ">"])
+    concat ["#HashDict<", Inspect.List.inspect(HashDict.to_list(dict), opts), ">"]
   end
 end

lib/elixir/lib/hash_set.ex

@@ -1,19 +1,17 @@
 defmodule HashSet do
   @moduledoc """
-  Tuple-based HashSet implementation.
+  WARNING: this module is deprecated.
 
-  This module is deprecated. Use the `MapSet` module instead.
+  Use the `MapSet` module instead.
   """
 
-  @moduledoc deprecated: "Use MapSet instead"
+  # TODO: Deprecate every function by 1.4
 
   @node_bitmap 0b111
   @node_shift 3
   @node_size 8
   @node_template :erlang.make_tuple(@node_size, [])
 
-  message = "Use the MapSet module instead"
-
   @opaque t :: %__MODULE__{size: non_neg_integer, root: term}
   @doc false
   defstruct size: 0, root: @node_template
@@ -22,85 +20,71 @@ defmodule HashSet do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
-  @deprecated message
-  @spec new :: Set.t()
+  @spec new :: Set.t
   def new do
     %HashSet{}
   end
 
-  @deprecated message
   def union(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) when size1 <= size2 do
-    set_fold(set1, set2, fn v, acc -> put(acc, v) end)
+    set_fold set1, set2, fn v, acc -> put(acc, v) end
   end
 
-  @deprecated message
   def union(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold(set2, set1, fn v, acc -> put(acc, v) end)
+    set_fold set2, set1, fn v, acc -> put(acc, v) end
   end
 
-  @deprecated message
   def intersection(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold(set1, %HashSet{}, fn v, acc ->
+    set_fold set1, %HashSet{}, fn v, acc ->
       if member?(set2, v), do: put(acc, v), else: acc
-    end)
-  end
-
-  @deprecated message
-  def difference(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold(set2, set1, fn v, acc -> delete(acc, v) end)
-  end
-
-  @deprecated message
-  def to_list(set) do
-    set_fold(set, [], &[&1 | &2]) |> :lists.reverse()
-  end
-
-  @deprecated message
-  def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
-    case size1 do
-      ^size2 -> subset?(set1, set2)
-      _ -> false
     end
   end
 
-  @deprecated message
+  def difference(%HashSet{} = set1, %HashSet{} = set2) do
+    set_fold set2, set1, fn v, acc -> delete(acc, v) end
+  end
+
+  def to_list(set) do
+    set_fold(set, [], &[&1 | &2]) |> :lists.reverse
+  end
+
+  def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
+    case size1 do
+      ^size2 -> subset?(set1, set2)
+      _      -> false
+    end
+  end
+
   def subset?(%HashSet{} = set1, %HashSet{} = set2) do
     reduce(set1, {:cont, true}, fn member, acc ->
       case member?(set2, member) do
         true -> {:cont, acc}
-        _ -> {:halt, false}
+        _    -> {:halt, false}
       end
-    end)
-    |> elem(1)
+    end) |> elem(1)
   end
 
-  @deprecated message
   def disjoint?(%HashSet{} = set1, %HashSet{} = set2) do
     reduce(set2, {:cont, true}, fn member, acc ->
       case member?(set1, member) do
         false -> {:cont, acc}
-        _ -> {:halt, false}
+        _     -> {:halt, false}
       end
-    end)
-    |> elem(1)
+    end) |> elem(1)
   end
 
-  @deprecated message
   def member?(%HashSet{root: root}, term) do
     do_member?(root, term, key_hash(term))
   end
 
-  @deprecated message
   def put(%HashSet{root: root, size: size}, term) do
     {root, counter} = do_put(root, term, key_hash(term))
     %HashSet{root: root, size: size + counter}
   end
 
-  @deprecated message
   def delete(%HashSet{root: root, size: size} = set, term) do
     case do_delete(root, term, key_hash(term)) do
       {:ok, root} -> %HashSet{root: root, size: size - 1}
-      :error -> set
+      :error      -> set
     end
   end
 
@@ -108,12 +92,11 @@ defmodule HashSet do
   def reduce(%HashSet{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc} -> {:halted, acc}
-      {:cont, acc} -> {:done, acc}
+      {:halt, acc}    -> {:halted, acc}
+      {:cont, acc}    -> {:done, acc}
     end)
   end
 
-  @deprecated message
   def size(%HashSet{size: size}) do
     size
   end
@@ -128,29 +111,24 @@ defmodule HashSet do
 
   defp do_member?(node, term, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
-      [] -> false
+      []          -> false
       [^term | _] -> true
-      [_] -> false
-      [_ | n] -> do_member?(n, term, key_shift(hash))
+      [_]         -> false
+      [_ | n]     -> do_member?(n, term, key_shift(hash))
     end
   end
 
   defp do_put(node, term, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [term]), 1}
-
       [^term | _] ->
         {node, 0}
-
       [t] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [term])
         {put_elem(node, index, [t | n]), 1}
-
       [t | n] ->
         {n, counter} = do_put(n, term, key_shift(hash))
         {put_elem(node, index, [t | n]), counter}
@@ -159,35 +137,28 @@ defmodule HashSet do
 
   defp do_delete(node, term, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         :error
-
       [^term] ->
         {:ok, put_elem(node, index, [])}
-
       [_] ->
         :error
-
       [^term | n] ->
         {:ok, put_elem(node, index, do_compact_node(n))}
-
       [t | n] ->
         case do_delete(n, term, key_shift(hash)) do
           {:ok, @node_template} ->
             {:ok, put_elem(node, index, [t])}
-
           {:ok, n} ->
             {:ok, put_elem(node, index, [t | n])}
-
           :error ->
             :error
         end
     end
   end
 
-  Enum.each(0..(@node_size - 1), fn index ->
+  Enum.each 0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
         [t] ->
@@ -195,17 +166,16 @@ defmodule HashSet do
             @node_template -> [t]
             n -> [t | n]
           end
-
         [t | n] ->
           [t | put_elem(node, unquote(index), do_compact_node(n))]
       end
     end
-  end)
+  end
 
   ## Set fold
 
-  defp do_fold_each([], acc, _fun), do: acc
-  defp do_fold_each([t], acc, fun), do: fun.(t, acc)
+  defp do_fold_each([], acc, _fun),     do: acc
+  defp do_fold_each([t], acc, fun),     do: fun.(t, acc)
   defp do_fold_each([t | n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
 
   defp do_fold(node, acc, fun, count) when count > 0 do
@@ -240,12 +210,7 @@ defmodule HashSet do
   end
 
   defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(
-      :erlang.element(count, node),
-      acc,
-      fun,
-      &do_reduce(node, &1, fun, count - 1, next)
-    )
+    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
   end
 
   defp do_reduce(_node, acc, _fun, 0, next) do
@@ -270,41 +235,18 @@ defmodule HashSet do
 end
 
 defimpl Enumerable, for: HashSet do
-  def reduce(set, acc, fun) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    module.reduce(set, acc, fun)
-  end
-
-  def member?(set, term) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {:ok, module.member?(set, term)}
-  end
-
-  def count(set) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {:ok, module.size(set)}
-  end
-
-  def slice(_set) do
-    {:error, __MODULE__}
-  end
+  def reduce(set, acc, fun), do: HashSet.reduce(set, acc, fun)
+  def member?(set, v),       do: {:ok, HashSet.member?(set, v)}
+  def count(set),            do: {:ok, HashSet.size(set)}
 end
 
 defimpl Collectable, for: HashSet do
   def into(original) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-
-    collector_fun = fn
-      set, {:cont, term} -> module.put(set, term)
+    {original, fn
+      set, {:cont, x} -> HashSet.put(set, x)
       set, :done -> set
       _, :halt -> :ok
-    end
-
-    {original, collector_fun}
+    end}
   end
 end
 
@@ -312,8 +254,6 @@ defimpl Inspect, for: HashSet do
   import Inspect.Algebra
 
   def inspect(set, opts) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    concat(["#HashSet<", Inspect.List.inspect(module.to_list(set), opts), ">"])
+    concat ["#HashSet<", Inspect.List.inspect(HashSet.to_list(set), opts), ">"]
   end
 end

lib/elixir/lib/inspect.ex

@@ -1,45 +1,42 @@
 import Kernel, except: [inspect: 1]
 import Inspect.Algebra
 
-alias Code.Identifier
-
 defprotocol Inspect do
   @moduledoc """
-  The `Inspect` protocol converts an Elixir data structure into an
-  algebra document.
-
-  This documentation refers to implementing the `Inspect` protocol
-  for your own data structures. To learn more about using inspect,
-  see `Kernel.inspect/2` and `IO.inspect/2`.
+  The `Inspect` protocol is responsible for converting any Elixir
+  data structure into an algebra document. This document is then
+  formatted, either in pretty printing format or a regular one.
 
   The `inspect/2` function receives the entity to be inspected
   followed by the inspecting options, represented by the struct
-  `Inspect.Opts`. Building of the algebra document is done with
-  `Inspect.Algebra`.
+  `Inspect.Opts`.
+
+  Inspection is done using the functions available in `Inspect.Algebra`.
 
   ## Examples
 
   Many times, inspecting a structure can be implemented in function
-  of existing entities. For example, here is `MapSet`'s `inspect/2`
+  of existing entities. For example, here is `MapSet`'s `inspect`
   implementation:
 
       defimpl Inspect, for: MapSet do
         import Inspect.Algebra
 
         def inspect(dict, opts) do
-          concat(["#MapSet<", to_doc(MapSet.to_list(dict), opts), ">"])
+          concat ["#MapSet<", to_doc(MapSet.to_list(dict), opts), ">"]
         end
       end
 
-  The [`concat/1`](`Inspect.Algebra.concat/1`) function comes from `Inspect.Algebra` and it
-  concatenates algebra documents together. In the example above it is
-  concatenating the string `"MapSet<"`, the document returned by
-  `Inspect.Algebra.to_doc/2`, and the final string `">"`. All strings are
-  valid algebra documents that keep their formatting when pretty printed.
+  The `concat/1` function comes from `Inspect.Algebra` and it
+  concatenates algebra documents together. In the example above,
+  it is concatenating the string `"MapSet<"` (all strings are
+  valid algebra documents that keep their formatting when pretty
+  printed), the document returned by `Inspect.Algebra.to_doc/2` and the
+  other string `">"`.
 
   Since regular strings are valid entities in an algebra document,
-  an implementation of the `Inspect` protocol may simply return a
-  string, although that will devoid it of any pretty-printing.
+  an implementation of inspect may simply return a string,
+  although that will devoid it of any pretty-printing.
 
   ## Error handling
 
@@ -47,44 +44,17 @@ defprotocol Inspect do
   Elixir will raise an `ArgumentError` error and will automatically fall back
   to a raw representation for printing the structure.
 
-  You can however access the underlying error by invoking the `Inspect`
-  implementation directly. For example, to test `Inspect.MapSet` above,
+  You can however access the underlying error by invoking the Inspect
+  implementation directly. For example, to test Inspect.MapSet above,
   you can invoke it as:
 
-      Inspect.MapSet.inspect(MapSet.new(), %Inspect.Opts{})
-
-  ## Deriving
-
-  The `Inspect` protocol can be derived to hide certain fields from
-  structs, so they don't show up in logs, inspects and similar. This
-  is especially useful for fields containing private information.
-
-  The options `:only` and `:except` can be used with `@derive` to
-  specify which fields should and should not appear in the
-  algebra document:
-
-      defmodule User do
-        @derive {Inspect, only: [:id, :name]}
-        defstruct [:id, :name, :address]
-      end
-
-      inspect(%User{id: 1, name: "Homer", address: "742 Evergreen Terrace"})
-      #=> #User<id: 1, name: "Homer", ...>
+      Inspect.MapSet.inspect(MapSet.new, %Inspect.Opts{})
 
   """
 
   # Handle structs in Any
   @fallback_to_any true
 
-  @doc """
-  Converts `term` into an algebra document.
-
-  This function shouldn't be invoked directly, unless when implementing
-  a custom `inspect_fun` to be given to `Inspect.Opts`. Everywhere else,
-  `Inspect.Algebra.to_doc/2` should be preferred as it handles structs
-  and exceptions.
-  """
-  @spec inspect(t, Inspect.Opts.t()) :: Inspect.Algebra.t()
   def inspect(term, opts)
 end
 
@@ -92,27 +62,93 @@ defimpl Inspect, for: Atom do
   require Macro
 
   def inspect(atom, opts) do
-    color(Identifier.inspect_as_atom(atom), color_key(atom), opts)
+    color(inspect(atom), color_key(atom), opts)
   end
 
   defp color_key(atom) when is_boolean(atom), do: :boolean
-  defp color_key(nil), do: nil
+  defp color_key(nil), do: :nil
   defp color_key(_), do: :atom
+
+  def inspect(false),  do: "false"
+  def inspect(true),   do: "true"
+  def inspect(nil),    do: "nil"
+  def inspect(:""),    do: ":\"\""
+
+  def inspect(atom) do
+    binary = Atom.to_string(atom)
+
+    cond do
+      valid_ref_identifier?(binary) ->
+        if only_elixir?(binary) do
+          binary
+        else
+          "Elixir." <> rest = binary
+          rest
+        end
+      valid_atom_identifier?(binary) ->
+        ":" <> binary
+      atom in [:%{}, :{}, :<<>>, :..., :%] ->
+        ":" <> binary
+      atom in Macro.binary_ops or atom in Macro.unary_ops ->
+        ":" <> binary
+      true ->
+        IO.iodata_to_binary [?:, ?", Inspect.BitString.escape(binary, ?"), ?"]
+    end
+  end
+
+  defp only_elixir?("Elixir." <> rest), do: only_elixir?(rest)
+  defp only_elixir?("Elixir"), do: true
+  defp only_elixir?(_), do: false
+
+  # Detect if atom is an atom alias (Elixir.Foo.Bar.Baz)
+
+  defp valid_ref_identifier?("Elixir" <> rest) do
+    valid_ref_piece?(rest)
+  end
+
+  defp valid_ref_identifier?(_), do: false
+
+  defp valid_ref_piece?(<<?., h, t::binary>>) when h in ?A..?Z do
+    valid_ref_piece? valid_identifier?(t)
+  end
+
+  defp valid_ref_piece?(<<>>), do: true
+  defp valid_ref_piece?(_),    do: false
+
+  # Detect if atom
+
+  defp valid_atom_identifier?(<<h, t::binary>>) when h in ?a..?z or h in ?A..?Z or h == ?_ do
+    valid_atom_piece?(t)
+  end
+
+  defp valid_atom_identifier?(_), do: false
+
+  defp valid_atom_piece?(t) do
+    case valid_identifier?(t) do
+      <<>>              -> true
+      <<??>>            -> true
+      <<?!>>            -> true
+      <<?@, t::binary>> -> valid_atom_piece?(t)
+      _                 -> false
+    end
+  end
+
+  defp valid_identifier?(<<h, t::binary>>)
+      when h in ?a..?z
+      when h in ?A..?Z
+      when h in ?0..?9
+      when h == ?_ do
+    valid_identifier? t
+  end
+
+  defp valid_identifier?(other), do: other
 end
 
 defimpl Inspect, for: BitString do
-  def inspect(term, opts) when is_binary(term) do
-    %Inspect.Opts{binaries: bins, base: base, printable_limit: printable_limit} = opts
-
-    if base == :decimal and
-         (bins == :as_strings or (bins == :infer and String.printable?(term, printable_limit))) do
-      inspected =
-        case Identifier.escape(term, ?", printable_limit) do
-          {escaped, ""} -> [?", escaped, ?"]
-          {escaped, _} -> [?", escaped, ?", " <> ..."]
-        end
-
-      color(IO.iodata_to_binary(inspected), :string, opts)
+  def inspect(term, %Inspect.Opts{binaries: bins, base: base} = opts) when is_binary(term) do
+    if base == :decimal and (bins == :as_strings or (bins == :infer and String.printable?(term))) do
+      inspected = IO.iodata_to_binary([?", escape(term, ?"), ?"])
+      color(inspected, :string, opts)
     else
       inspect_bitstring(term, opts)
     end
@@ -122,6 +158,88 @@ defimpl Inspect, for: BitString do
     inspect_bitstring(term, opts)
   end
 
+  ## Escaping
+
+  @doc false
+  def escape(other, char) do
+    escape(other, char, [])
+  end
+
+  defp escape(<<char, t::binary>>, char, acc) do
+    escape(t, char, [acc | [?\\, char]])
+  end
+  defp escape(<<?#, ?{, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\\#{'])
+  end
+  defp escape(<<?\a, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\a'])
+  end
+  defp escape(<<?\b, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\b'])
+  end
+  defp escape(<<?\d, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\d'])
+  end
+  defp escape(<<?\e, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\e'])
+  end
+  defp escape(<<?\f, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\f'])
+  end
+  defp escape(<<?\n, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\n'])
+  end
+  defp escape(<<?\r, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\r'])
+  end
+  defp escape(<<?\\, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\\\'])
+  end
+  defp escape(<<?\t, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\t'])
+  end
+  defp escape(<<?\v, t::binary>>, char, acc) do
+    escape(t, char, [acc | '\\v'])
+  end
+  defp escape(<<h::utf8, t::binary>>, char, acc)
+       when h in 0x20..0x7E
+       when h in 0xA0..0xD7FF
+       when h in 0xE000..0xFFFD
+       when h in 0x10000..0x10FFFF do
+    escape(t, char, [acc | <<h::utf8>>])
+  end
+  defp escape(<<h, t::binary>>, char, acc) do
+    escape(t, char, [acc | escape_char(h)])
+  end
+  defp escape(<<>>, _char, acc), do: acc
+
+  @doc false
+  # Also used by Regex
+  def escape_char(0) do
+    '\\0'
+  end
+
+  def escape_char(char) when char < 0x100 do
+    <<a::4, b::4>> = <<char::8>>
+    ['\\x', to_hex(a), to_hex(b)]
+  end
+
+  def escape_char(char) when char < 0x10000 do
+    <<a::4, b::4, c::4, d::4>> = <<char::16>>
+    ['\\x{', to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}]
+  end
+
+  def escape_char(char) when char < 0x1000000 do
+    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
+    ['\\x{', to_hex(a), to_hex(b), to_hex(c),
+             to_hex(d), to_hex(e), to_hex(f), ?}]
+  end
+
+  defp to_hex(c) when c in 0..9, do: ?0+c
+  defp to_hex(c) when c in 10..15, do: ?A+c-10
+
+  ## Bitstrings
+
   defp inspect_bitstring("", opts) do
     color("<<>>", :binary, opts)
   end
@@ -129,8 +247,7 @@ defimpl Inspect, for: BitString do
   defp inspect_bitstring(bitstring, opts) do
     left = color("<<", :binary, opts)
     right = color(">>", :binary, opts)
-    inner = each_bit(bitstring, opts.limit, opts)
-    group(concat(concat(left, nest(inner, 2)), right))
+    nest surround(left, each_bit(bitstring, opts.limit, opts), right), 1
   end
 
   defp each_bit(_, 0, _) do
@@ -146,10 +263,8 @@ defimpl Inspect, for: BitString do
   end
 
   defp each_bit(<<h, t::bitstring>>, counter, opts) do
-    flex_glue(
-      concat(Inspect.Integer.inspect(h, opts), ","),
-      each_bit(t, decrement(counter), opts)
-    )
+    glue(concat(Inspect.Integer.inspect(h, opts), ","),
+         each_bit(t, decrement(counter), opts))
   end
 
   defp each_bit(bitstring, _counter, opts) do
@@ -158,9 +273,8 @@ defimpl Inspect, for: BitString do
     Inspect.Integer.inspect(h, opts) <> "::size(" <> Integer.to_string(size) <> ")"
   end
 
-  @compile {:inline, decrement: 1}
   defp decrement(:infinity), do: :infinity
-  defp decrement(counter), do: counter - 1
+  defp decrement(counter),   do: counter - 1
 end
 
 defimpl Inspect, for: List do
@@ -168,28 +282,14 @@ defimpl Inspect, for: List do
     color("[]", :list, opts)
   end
 
-  # TODO: Remove :char_list and :as_char_lists handling on v2.0
-  def inspect(term, opts) do
-    %Inspect.Opts{
-      charlists: lists,
-      char_lists: lists_deprecated,
-      printable_limit: printable_limit
-    } = opts
-
+  # TODO: Deprecate :char_lists and :as_char_lists keys in v1.5
+  def inspect(term, %Inspect.Opts{charlists: lists, char_lists: lists_deprecated} = opts) do
     lists =
       if lists == :infer and lists_deprecated != :infer do
         case lists_deprecated do
           :as_char_lists ->
-            IO.warn(
-              "the :char_lists inspect option and its :as_char_lists " <>
-                "value are deprecated, use the :charlists option and its " <>
-                ":as_charlists value instead"
-            )
-
             :as_charlists
-
           _ ->
-            IO.warn("the :char_lists inspect option is deprecated, use :charlists instead")
             lists_deprecated
         end
       else
@@ -201,27 +301,19 @@ defimpl Inspect, for: List do
     close = color("]", :list, opts)
 
     cond do
-      lists == :as_charlists or (lists == :infer and List.ascii_printable?(term, printable_limit)) ->
-        inspected =
-          case Identifier.escape(IO.chardata_to_string(term), ?', printable_limit) do
-            {escaped, ""} -> [?', escaped, ?']
-            {escaped, _} -> [?', escaped, ?', " ++ ..."]
-          end
-
-        IO.iodata_to_binary(inspected)
-
+      lists == :as_charlists or (lists == :infer and printable?(term)) ->
+        IO.iodata_to_binary [?', Inspect.BitString.escape(IO.chardata_to_string(term), ?'), ?']
       keyword?(term) ->
-        container_doc(open, term, close, opts, &keyword/2, separator: sep, break: :strict)
-
+        surround_many(open, term, close, opts, &keyword/2, sep)
       true ->
-        container_doc(open, term, close, opts, &to_doc/2, separator: sep)
+        surround_many(open, term, close, opts, &to_doc/2, sep)
     end
   end
 
   @doc false
   def keyword({key, value}, opts) do
-    key = color(Identifier.inspect_as_key(key), :atom, opts)
-    concat(key, concat(" ", to_doc(value, opts)))
+    key = color(key_to_binary(key) <> ": ", :atom, opts)
+    concat(key, to_doc(value, opts))
   end
 
   @doc false
@@ -232,8 +324,30 @@ defimpl Inspect, for: List do
     end
   end
 
-  def keyword?([]), do: true
+  def keyword?([]),     do: true
   def keyword?(_other), do: false
+
+  @doc false
+  def printable?([char | rest]) when char in 32..126, do: printable?(rest)
+  def printable?([?\n | rest]), do: printable?(rest)
+  def printable?([?\r | rest]), do: printable?(rest)
+  def printable?([?\t | rest]), do: printable?(rest)
+  def printable?([?\v | rest]), do: printable?(rest)
+  def printable?([?\b | rest]), do: printable?(rest)
+  def printable?([?\f | rest]), do: printable?(rest)
+  def printable?([?\e | rest]), do: printable?(rest)
+  def printable?([?\a | rest]), do: printable?(rest)
+  def printable?([]), do: true
+  def printable?(_), do: false
+
+  ## Private
+
+  defp key_to_binary(key) do
+    case Inspect.Atom.inspect(key) do
+      ":" <> right -> right
+      other -> other
+    end
+  end
 end
 
 defimpl Inspect, for: Tuple do
@@ -241,35 +355,36 @@ defimpl Inspect, for: Tuple do
     open = color("{", :tuple, opts)
     sep = color(",", :tuple, opts)
     close = color("}", :tuple, opts)
-    container_opts = [separator: sep, break: :flex]
-    container_doc(open, Tuple.to_list(tuple), close, opts, &to_doc/2, container_opts)
+    surround_many(open, Tuple.to_list(tuple), close, opts, &to_doc/2, sep)
   end
 end
 
 defimpl Inspect, for: Map do
   def inspect(map, opts) do
-    inspect(map, "", opts)
+    nest inspect(map, "", opts), 1
   end
 
   def inspect(map, name, opts) do
-    map = Map.to_list(map)
+    map = :maps.to_list(map)
     open = color("%" <> name <> "{", :map, opts)
     sep = color(",", :map, opts)
     close = color("}", :map, opts)
-    container_doc(open, map, close, opts, traverse_fun(map, opts), separator: sep, break: :strict)
+    surround_many(open, map, close, opts, traverse_fun(map), sep)
   end
 
-  defp traverse_fun(list, opts) do
+  defp traverse_fun(list) do
     if Inspect.List.keyword?(list) do
       &Inspect.List.keyword/2
     else
-      sep = color(" => ", :map, opts)
-      &to_map(&1, &2, sep)
+      &to_map/2
     end
   end
 
-  defp to_map({key, value}, opts, sep) do
-    concat(concat(to_doc(key, opts), sep), to_doc(value, opts))
+  defp to_map({key, value}, opts) do
+    concat(
+      concat(to_doc(key, opts), " => "),
+      to_doc(value, opts)
+    )
   end
 end
 
@@ -281,27 +396,20 @@ defimpl Inspect, for: Integer do
 
   defp base_to_value(base) do
     case base do
-      :binary -> 2
+      :binary  -> 2
       :decimal -> 10
-      :octal -> 8
-      :hex -> 16
+      :octal   -> 8
+      :hex     -> 16
     end
   end
 
   defp prepend_prefix(value, :decimal), do: value
-
-  defp prepend_prefix(<<?-, value::binary>>, base) do
-    "-" <> prepend_prefix(value, base)
-  end
-
   defp prepend_prefix(value, base) do
-    prefix =
-      case base do
-        :binary -> "0b"
-        :octal -> "0o"
-        :hex -> "0x"
-      end
-
+    prefix = case base do
+      :binary -> "0b"
+      :octal  -> "0o"
+      :hex    -> "0x"
+    end
     prefix <> value
   end
 end
@@ -315,57 +423,77 @@ end
 
 defimpl Inspect, for: Regex do
   def inspect(regex, opts) do
-    {escaped, _} =
-      regex.source
-      |> normalize(<<>>)
-      |> Identifier.escape(?/, :infinity, &escape_map/1)
-
-    source = IO.iodata_to_binary(['~r/', escaped, ?/, regex.opts])
+    source = IO.iodata_to_binary(['~r/', escape(regex.source, ?/), ?/, regex.opts])
     color(source, :regex, opts)
   end
 
-  defp normalize(<<?\\, ?\\, rest::binary>>, acc), do: normalize(rest, <<acc::binary, ?\\, ?\\>>)
-  defp normalize(<<?\\, ?/, rest::binary>>, acc), do: normalize(rest, <<acc::binary, ?/>>)
-  defp normalize(<<char, rest::binary>>, acc), do: normalize(rest, <<acc::binary, char>>)
-  defp normalize(<<>>, acc), do: acc
+  defp escape(bin, term),
+    do: escape(bin, [], term)
 
-  defp escape_map(?\a), do: '\\a'
-  defp escape_map(?\f), do: '\\f'
-  defp escape_map(?\n), do: '\\n'
-  defp escape_map(?\r), do: '\\r'
-  defp escape_map(?\t), do: '\\t'
-  defp escape_map(?\v), do: '\\v'
-  defp escape_map(_), do: false
+  defp escape(<<?\\, term>> <> rest, buf, term),
+    do: escape(rest, [buf | [?\\, term]], term)
+
+  defp escape(<<term>> <> rest, buf, term),
+    do: escape(rest, [buf | [?\\, term]], term)
+
+  # The list of characters is from 'String.printable?' implementation
+  # minus characters treated specially by regex: \s, \d, \b, \e
+
+  defp escape(<<?\n>> <> rest, buf, term),
+    do: escape(rest, [buf | '\\n'], term)
+
+  defp escape(<<?\r>> <> rest, buf, term),
+    do: escape(rest, [buf | '\\r'], term)
+
+  defp escape(<<?\t>> <> rest, buf, term),
+    do: escape(rest, [buf | '\\t'], term)
+
+  defp escape(<<?\v>> <> rest, buf, term),
+    do: escape(rest, [buf | '\\v'], term)
+
+  defp escape(<<?\f>> <> rest, buf, term),
+    do: escape(rest, [buf | '\\f'], term)
+
+  defp escape(<<?\a>> <> rest, buf, term),
+    do: escape(rest, [buf | '\\a'], term)
+
+  defp escape(<<char::utf8, rest::binary>>, buf, term)
+       when char in 0x20..0x7E
+       when char in 0xA0..0xD7FF
+       when char in 0xE000..0xFFFD
+       when char in 0x10000..0x10FFFF,
+    do: escape(rest, [buf | <<char::utf8>>], term)
+
+  defp escape(<<char, rest::binary>>, buf, term),
+    do: escape(rest, [buf | Inspect.BitString.escape_char(char)], term)
+
+  defp escape(<<>>, buf, _), do: buf
 end
 
 defimpl Inspect, for: Function do
   def inspect(function, _opts) do
-    fun_info = Function.info(function)
+    fun_info = :erlang.fun_info(function)
     mod = fun_info[:module]
-    name = fun_info[:name]
 
-    cond do
-      fun_info[:type] == :external and fun_info[:env] == [] ->
-        inspected_as_atom = Identifier.inspect_as_atom(mod)
-        inspected_as_function = Identifier.inspect_as_function(name)
-        "&#{inspected_as_atom}.#{inspected_as_function}/#{fun_info[:arity]}"
-
-      match?('elixir_compiler_' ++ _, Atom.to_charlist(mod)) ->
-        if function_exported?(mod, :__RELATIVE__, 0) do
-          "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
-        else
+    if fun_info[:type] == :external and fun_info[:env] == [] do
+      "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
+    else
+      case Atom.to_charlist(mod) do
+        'elixir_compiler_' ++ _ ->
+          if function_exported?(mod, :__RELATIVE__, 0) do
+            "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
+          else
+            default_inspect(mod, fun_info)
+          end
+        _ ->
           default_inspect(mod, fun_info)
-        end
-
-      true ->
-        default_inspect(mod, fun_info)
+      end
     end
   end
 
   defp default_inspect(mod, fun_info) do
-    inspected_as_atom = Identifier.inspect_as_atom(mod)
-    extracted_name = extract_name(fun_info[:name])
-    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in #{inspected_as_atom}#{extracted_name}>"
+    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in " <>
+      "#{Inspect.Atom.inspect(mod)}#{extract_name(fun_info[:name])}>"
   end
 
   defp extract_name([]) do
@@ -373,17 +501,16 @@ defimpl Inspect, for: Function do
   end
 
   defp extract_name(name) do
-    case Identifier.extract_anonymous_fun_parent(name) do
-      {name, arity} ->
-        "." <> Identifier.inspect_as_function(name) <> "/" <> arity
-
-      :error ->
-        "." <> Identifier.inspect_as_function(name)
+    name = Atom.to_string(name)
+    case :binary.split(name, "-", [:global]) do
+      ["", name | _] -> "." <> name
+      _ -> "." <> name
     end
   end
 
   defp uniq(fun_info) do
-    Integer.to_string(fun_info[:new_index]) <> "." <> Integer.to_string(fun_info[:uniq])
+    Integer.to_string(fun_info[:new_index]) <> "." <>
+      Integer.to_string(fun_info[:uniq])
   end
 end
 
@@ -407,81 +534,20 @@ defimpl Inspect, for: Reference do
 end
 
 defimpl Inspect, for: Any do
-  defmacro __deriving__(module, struct, options) do
-    fields = Map.keys(struct) -- [:__exception__, :__struct__]
-    only = Keyword.get(options, :only, fields)
-    except = Keyword.get(options, :except, [])
-
-    filtered_fields =
-      fields
-      |> Enum.reject(&(&1 in except))
-      |> Enum.filter(&(&1 in only))
-
-    inspect_module =
-      if fields == only and except == [] do
-        Inspect.Map
-      else
-        Inspect.Any
-      end
-
-    quote do
-      defimpl Inspect, for: unquote(module) do
-        def inspect(var!(struct), var!(opts)) do
-          var!(map) = Map.take(var!(struct), unquote(filtered_fields))
-          var!(name) = Identifier.inspect_as_atom(unquote(module))
-          unquote(inspect_module).inspect(var!(map), var!(name), var!(opts))
-        end
-      end
-    end
-  end
-
-  def inspect(%module{} = struct, opts) do
+  def inspect(%{__struct__: struct} = map, opts) do
     try do
-      module.__struct__
+      struct.__struct__
     rescue
-      _ -> Inspect.Map.inspect(struct, opts)
+      _ -> Inspect.Map.inspect(map, opts)
     else
       dunder ->
-        if Map.keys(dunder) == Map.keys(struct) do
-          pruned = Map.drop(struct, [:__struct__, :__exception__])
-          Inspect.Map.inspect(pruned, Identifier.inspect_as_atom(module), opts)
+        if :maps.keys(dunder) == :maps.keys(map) do
+          pruned = :maps.remove(:__exception__, :maps.remove(:__struct__, map))
+          colorless_opts = %{opts | syntax_colors: []}
+          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(struct, colorless_opts), opts)
         else
-          Inspect.Map.inspect(struct, opts)
+          Inspect.Map.inspect(map, opts)
         end
     end
   end
-
-  def inspect(map, name, opts) do
-    # Use the :limit option and an extra element to force
-    # `container_doc/6` to append "...".
-    opts = %{opts | limit: min(opts.limit, map_size(map))}
-    map = Map.to_list(map) ++ ["..."]
-
-    open = color("#" <> name <> "<", :map, opts)
-    sep = color(",", :map, opts)
-    close = color(">", :map, opts)
-
-    container_doc(open, map, close, opts, &Inspect.List.keyword/2, separator: sep, break: :strict)
-  end
 end
-
-require Protocol
-
-Protocol.derive(
-  Inspect,
-  Macro.Env,
-  only: [
-    :module,
-    :file,
-    :line,
-    :function,
-    :context,
-    :aliases,
-    :requires,
-    :functions,
-    :macros,
-    :macro_aliases,
-    :context_modules,
-    :lexical_tracker
-  ]
-)

lib/elixir/lib/integer.ex

@@ -1,15 +1,6 @@
 defmodule Integer do
   @moduledoc """
   Functions for working with integers.
-
-  Some functions that work on integers are found in `Kernel`:
-
-    * `abs/1`
-    * `div/2`
-    * `max/2`
-    * `min/2`
-    * `rem/2`
-
   """
 
   import Bitwise
@@ -37,7 +28,9 @@ defmodule Integer do
       false
 
   """
-  defguard is_odd(integer) when is_integer(integer) and (integer &&& 1) == 1
+  defmacro is_odd(integer) do
+    quote do: (unquote(integer) &&& 1) == 1
+  end
 
   @doc """
   Determines if an `integer` is even.
@@ -62,7 +55,9 @@ defmodule Integer do
       true
 
   """
-  defguard is_even(integer) when is_integer(integer) and (integer &&& 1) == 0
+  defmacro is_even(integer) do
+    quote do: (unquote(integer) &&& 1) == 0
+  end
 
   @doc """
   Computes the modulo remainder of an integer division.
@@ -81,11 +76,9 @@ defmodule Integer do
       -2
 
   """
-  @doc since: "1.4.0"
   @spec mod(integer, neg_integer | pos_integer) :: integer
   def mod(dividend, divisor) do
     remainder = rem(dividend, divisor)
-
     if remainder * divisor < 0 do
       remainder + divisor
     else
@@ -115,10 +108,9 @@ defmodule Integer do
       -50
 
   """
-  @doc since: "1.4.0"
   @spec floor_div(integer, neg_integer | pos_integer) :: integer
   def floor_div(dividend, divisor) do
-    if dividend * divisor < 0 and rem(dividend, divisor) != 0 do
+    if (dividend * divisor < 0) and rem(dividend, divisor) != 0 do
       div(dividend, divisor) - 1
     else
       div(dividend, divisor)
@@ -149,8 +141,14 @@ defmodule Integer do
     do_digits(integer, base, [])
   end
 
-  defp do_digits(integer, base, acc) when abs(integer) < base, do: [integer | acc]
-
+  defp do_digits(digit, base, []) when abs(digit) < base,
+    do: [digit]
+  defp do_digits(digit, base, []) when digit == -base,
+    do: [-1, 0]
+  defp do_digits(base, base, []),
+    do: [1, 0]
+  defp do_digits(0, _base, acc),
+    do: acc
   defp do_digits(integer, base, acc),
     do: do_digits(div(integer, base), base, [rem(integer, base) | acc])
 
@@ -158,7 +156,7 @@ defmodule Integer do
   Returns the integer represented by the ordered `digits`.
 
   An optional `base` value may be provided representing the radix for the `digits`.
-  Base has to be an integer greater than or equal to `2`.
+  This one can be an integer >= 2.
 
   ## Examples
 
@@ -172,16 +170,24 @@ defmodule Integer do
       0
 
   """
-  @spec undigits([integer], pos_integer) :: integer
+  @spec undigits([integer], integer) :: integer
   def undigits(digits, base \\ 10) when is_list(digits) and is_integer(base) and base >= 2 do
     do_undigits(digits, base, 0)
   end
 
-  defp do_undigits([], _base, acc), do: acc
+  defp do_undigits([], _base, 0),
+    do: 0
+  defp do_undigits([digit], base, 0) when is_integer(digit) and digit < base,
+    do: digit
+  defp do_undigits([1, 0], base, 0),
+    do: base
+  defp do_undigits([0 | tail], base, 0),
+    do: do_undigits(tail, base, 0)
 
+  defp do_undigits([], _base, acc),
+    do: acc
   defp do_undigits([digit | _], base, _) when is_integer(digit) and digit >= base,
-    do: raise(ArgumentError, "invalid digit #{digit} in base #{base}")
-
+    do: raise ArgumentError, "invalid digit #{digit} in base #{base}"
   defp do_undigits([digit | tail], base, acc) when is_integer(digit),
     do: do_undigits(tail, base, acc * base + digit)
 
@@ -196,7 +202,7 @@ defmodule Integer do
 
   Raises an error if `base` is less than 2 or more than 36.
 
-  If you want to convert a string-formatted integer directly to an integer,
+  If you want to convert a string-formatted integer directly to a integer,
   `String.to_integer/1` or `String.to_integer/2` can be used instead.
 
   ## Examples
@@ -226,52 +232,75 @@ defmodule Integer do
       ** (ArgumentError) invalid base 38
 
   """
-  @spec parse(binary, 2..36) :: {integer, binary} | :error
+  @spec parse(binary, 2..36) :: {integer, binary} | :error | no_return
   def parse(binary, base \\ 10)
 
-  def parse(_binary, base) when base not in 2..36 do
-    raise ArgumentError, "invalid base #{inspect(base)}"
+  def parse("", base) when base in 2..36,
+    do: :error
+
+  def parse(binary, base) when is_binary(binary) and base in 2..36 do
+    parse_in_base(binary, base)
   end
 
   def parse(binary, base) when is_binary(binary) do
-    case count_digits(binary, base) do
-      0 ->
-        :error
+    raise ArgumentError, "invalid base #{base}"
+  end
 
-      count ->
-        {digits, rem} = :erlang.split_binary(binary, count)
-        {:erlang.binary_to_integer(digits, base), rem}
+  defp parse_in_base("-" <> bin, base) do
+    case do_parse(bin, base) do
+      {number, remainder} -> {-number, remainder}
+      :error -> :error
     end
   end
 
-  defp count_digits(<<sign, rest::bits>>, base) when sign in '+-' do
-    case count_digits_nosign(rest, base, 1) do
-      1 -> 0
-      count -> count
+  defp parse_in_base("+" <> bin, base) do
+    do_parse(bin, base)
+  end
+
+  defp parse_in_base(binary, base) when is_binary(binary) do
+    do_parse(binary, base)
+  end
+
+  defp do_parse(<<char, rest::binary>>, base) do
+    if valid_digit_in_base?(char, base) do
+      do_parse(rest, base, parse_digit(char))
+    else
+      :error
     end
   end
 
-  defp count_digits(<<rest::bits>>, base) do
-    count_digits_nosign(rest, base, 0)
+  defp do_parse(_, _) do
+    :error
   end
 
-  digits = [{?0..?9, -?0}, {?A..?Z, 10 - ?A}, {?a..?z, 10 - ?a}]
-
-  for {chars, diff} <- digits,
-      char <- chars do
-    digit = char + diff
-
-    defp count_digits_nosign(<<unquote(char), rest::bits>>, base, count)
-         when base > unquote(digit) do
-      count_digits_nosign(rest, base, count + 1)
+  defp do_parse(<<char, rest::binary>> = bin, base, acc) do
+    if valid_digit_in_base?(char, base) do
+      do_parse(rest, base, base * acc + parse_digit(char))
+    else
+      {acc, bin}
     end
   end
 
-  defp count_digits_nosign(<<_::bits>>, _, count), do: count
+  defp do_parse(bitstring, _, acc) do
+    {acc, bitstring}
+  end
+
+  defp parse_digit(char) do
+    cond do
+      char in ?0..?9 -> char - ?0
+      char in ?A..?Z -> char - ?A + 10
+      true           -> char - ?a + 10
+    end
+  end
+
+  defp valid_digit_in_base?(char, base) do
+    if base <= 10 do
+      char in ?0..(?0 + base - 1)
+    else
+      char in ?0..?9 or char in ?A..(?A + base - 11) or char in ?a..(?a + base - 11)
+    end
+  end
 
-  # TODO: Remove Integer.to_string/1 once the minimum supported version is
-  #       Erlang/OTP 22, since it is covered by the now BIF Integer.to_string/2.
-  #       Please reapply commit 2622fd6b0aa419a983a899a1fbdb5deefba3d85d.
   @doc """
   Returns a binary which corresponds to the text representation
   of `integer`.
@@ -293,7 +322,7 @@ defmodule Integer do
       "123"
 
   """
-  @spec to_string(integer) :: String.t()
+  @spec to_string(integer) :: String.t
   def to_string(integer) do
     :erlang.integer_to_binary(integer)
   end
@@ -314,18 +343,15 @@ defmodule Integer do
       iex> Integer.to_string(-100, 16)
       "-64"
 
-      iex> Integer.to_string(882_681_651, 36)
+      iex> Integer.to_string(882681651, 36)
       "ELIXIR"
 
   """
-  @spec to_string(integer, 2..36) :: String.t()
+  @spec to_string(integer, 2..36) :: String.t
   def to_string(integer, base) do
     :erlang.integer_to_binary(integer, base)
   end
 
-  # TODO: Remove Integer.to_charlist/1 once the minimum supported version is
-  #       Erlang/OTP 22, since it is covered by the now BIF Integer.to_charlist/2.
-  #       Please reapply commit 2622fd6b0aa419a983a899a1fbdb5deefba3d85d.
   @doc """
   Returns a charlist which corresponds to the text representation of the given `integer`.
 
@@ -366,7 +392,7 @@ defmodule Integer do
       iex> Integer.to_charlist(-100, 16)
       '-64'
 
-      iex> Integer.to_charlist(882_681_651, 36)
+      iex> Integer.to_charlist(882681651, 36)
       'ELIXIR'
 
   """
@@ -375,50 +401,8 @@ defmodule Integer do
     :erlang.integer_to_list(integer, base)
   end
 
-  @doc """
-  Returns the greatest common divisor of the two given integers.
-
-  The greatest common divisor (GCD) of `integer1` and `integer2` is the largest positive
-  integer that divides both `integer1` and `integer2` without leaving a remainder.
-
-  By convention, `gcd(0, 0)` returns `0`.
-
-  ## Examples
-
-      iex> Integer.gcd(2, 3)
-      1
-
-      iex> Integer.gcd(8, 12)
-      4
-
-      iex> Integer.gcd(8, -12)
-      4
-
-      iex> Integer.gcd(10, 0)
-      10
-
-      iex> Integer.gcd(7, 7)
-      7
-
-      iex> Integer.gcd(0, 0)
-      0
-
-  """
-  @doc since: "1.5.0"
-  @spec gcd(integer, integer) :: non_neg_integer
-  def gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
-    gcd_positive(abs(integer1), abs(integer2))
-  end
-
-  defp gcd_positive(0, integer2), do: integer2
-  defp gcd_positive(integer1, 0), do: integer1
-  defp gcd_positive(integer1, integer2), do: gcd_positive(integer2, rem(integer1, integer2))
-
+  # TODO: Deprecate by v1.5
   @doc false
-  @deprecated "Use Integer.to_charlist/1 instead"
+  @spec to_char_list(integer) :: charlist
   def to_char_list(integer), do: Integer.to_charlist(integer)
-
-  @doc false
-  @deprecated "Use Integer.to_charlist/2 instead"
-  def to_char_list(integer, base), do: Integer.to_charlist(integer, base)
 end

lib/elixir/lib/io.ex

@@ -1,5 +1,5 @@
 defmodule IO do
-  @moduledoc ~S"""
+  @moduledoc """
   Functions handling input/output (IO).
 
   Many functions in this module expect an IO device as an argument.
@@ -7,10 +7,13 @@ defmodule IO do
   For convenience, Elixir provides `:stdio` and `:stderr` as
   shortcuts to Erlang's `:standard_io` and `:standard_error`.
 
-  The majority of the functions expect chardata. In case another type is given,
-  functions will convert those types to string via the `String.Chars` protocol
-  (as shown in typespecs). For more information on chardata, see the
-  "IO data" section below.
+  The majority of the functions expect chardata, i.e. strings or
+  lists of characters and strings. In case another type is given,
+  functions will convert to string via the `String.Chars` protocol
+  (as shown in typespecs).
+
+  The functions starting with `bin` expect iodata as an argument,
+  i.e. binaries or lists of bytes and binaries.
 
   ## IO devices
 
@@ -24,105 +27,22 @@ defmodule IO do
     * `:stderr` - a shortcut for the named process `:standard_error`
       provided in Erlang
 
-  IO devices maintain their position, which means subsequent calls to any
-  reading or writing functions will start from the place where the device
-  was last accessed. The position of files can be changed using the
+  IO devices maintain their position, that means subsequent calls to any
+  reading or writing functions will start from the place when the device
+  was last accessed. Position of files can be changed using the
   `:file.position/2` function.
 
-  ## IO data
-
-  IO data is a data type that can be used as a more efficient alternative to binaries
-  in certain situations.
-
-  A term of type **IO data** is a binary or a list containing bytes (integers in `0..255`)
-  or nested IO data. The type is recursive. Let's see an example of one of
-  the possible IO data representing the binary `"hello"`:
-
-      [?h, "el", ["l", [?o]]]
-
-  The built-in `t:iodata/0` type is defined in terms of `t:iolist/0`. An IO list is
-  the same as IO data but it doesn't allow for a binary at the top level (but binaries
-  are still allowed in the list itself).
-
-  ### Use cases for IO data
-
-  IO data exists because often you need to do many append operations
-  on smaller chunks of binaries in order to create a bigger binary. However, in
-  Erlang and Elixir concatenating binaries will copy the concatenated binaries
-  into a new binary.
-
-      def email(username, domain) do
-        username <> "@" <> domain
-      end
-
-  In this function, creating the email address will copy the `username` and `domain`
-  binaries. Now imagine you want to use the resulting email inside another binary:
-
-      def welcome_message(name, username, domain) do
-        "Welcome #{name}, your email is: #{email(username, domain)}"
-      end
-
-      IO.puts(welcome_message("Meg", "meg", "example.com"))
-      #=> "Welcome Meg, your email is: meg@example.com"
-
-  Every time you concatenate binaries or use interpolation (`#{}`) you are making
-  copies of those binaries. However, in many cases you don't need the complete
-  binary while you create it, but only at the end to print it out or send it
-  somewhere. In such cases, you can construct the binary by creating IO data:
-
-      def email(username, domain) do
-        [username, ?@, domain]
-      end
-
-      def welcome_message(name, username, domain) do
-        ["Welcome ", name, ", your email is: ", email(username, domain)]
-      end
-
-      IO.puts(welcome_message("Meg", "meg", "example.com"))
-      #=> "Welcome Meg, your email is: meg@example.com"
-
-  Building IO data is cheaper than concatenating binaries. Concatenating multiple
-  pieces of IO data just means putting them together inside a list since IO data
-  can be arbitrarily nested, and that's a cheap and efficient operation. Most of
-  the IO-based APIs, such as `:gen_tcp` and `IO`, receive IO data and write it
-  to the socket directly without converting it to binary.
-
-  One drawback of IO data is that you can't do things like pattern match on the
-  first part of a piece of IO data like you can with a binary, because you usually
-  don't know the shape of the IO data. In those cases, you may need to convert it
-  to a binary by calling `iodata_to_binary/1`, which is reasonably efficient
-  since it's implemented natively in C. Other functionality, like computing the
-  length of IO data, can be computed directly on the iodata by calling `iodata_length/1`.
-
-  ### Chardata
-
-  Erlang and Elixir also have the idea of `t:chardata/0`. Chardata is very
-  similar to IO data: the only difference is that integers in IO data represent
-  bytes while integers in chardata represent Unicode code points. Bytes
-  (`t:byte/0`) are integers in the `0..255` range, while Unicode code points
-  (`t:char/0`) are integers in the range `0..0x10FFFF`. The `IO` module provides
-  the `chardata_to_string/1` function for chardata as the "counter-part" of the
-  `iodata_to_binary/1` function for IO data.
-
-  If you try to use `iodata_to_binary/1` on chardata, it will result in an
-  argument error. For example, let's try to put a code point that is not
-  representable with one byte, like `?π`, inside IO data:
-
-      iex> IO.iodata_to_binary(["The symbol for pi is: ", ?π])
-      ** (ArgumentError) argument error
-
-  If we use chardata instead, it will work as expected:
-
-      iex> IO.chardata_to_string(["The symbol for pi is: ", ?π])
-      "The symbol for pi is: π"
-
   """
 
   @type device :: atom | pid
   @type nodata :: {:error, term} | :eof
-  @type chardata :: String.t() | maybe_improper_list(char | chardata, String.t() | [])
+  @type chardata() :: :unicode.chardata()
 
-  defguardp is_iodata(data) when is_list(data) or is_binary(data)
+  defmacrop is_iodata(data) do
+    quote do
+      is_list(unquote(data)) or is_binary(unquote(data))
+    end
+  end
 
   @doc """
   Reads from the IO `device`.
@@ -148,7 +68,7 @@ defmodule IO do
   def read(device \\ :stdio, line_or_chars)
 
   def read(device, :all) do
-    do_read_all(map_dev(device), :empty)
+    do_read_all(map_dev(device), "")
   end
 
   def read(device, :line) do
@@ -161,27 +81,12 @@ defmodule IO do
 
   defp do_read_all(mapped_dev, acc) do
     case :io.get_line(mapped_dev, "") do
-      line when is_binary(line) or is_list(line) -> do_read_all(mapped_dev, concat(acc, line))
-      :eof -> read_eof(mapped_dev, acc)
+      line when is_binary(line) -> do_read_all(mapped_dev, acc <> line)
+      :eof -> acc
       other -> other
     end
   end
 
-  defp concat(:empty, line), do: line
-  defp concat(acc, line) when is_binary(acc), do: acc <> line
-  defp concat(acc, line) when is_list(acc), do: acc ++ line
-
-  defp read_eof(device, :empty) do
-    with [_ | _] = opts <- :io.getopts(device),
-         false <- Keyword.get(opts, :binary, true) do
-      ''
-    else
-      _ -> ""
-    end
-  end
-
-  defp read_eof(_device, acc), do: acc
-
   @doc """
   Reads from the IO `device`. The operation is Unicode unsafe.
 
@@ -236,65 +141,47 @@ defmodule IO do
   end
 
   @doc """
-  Writes `chardata` to the given `device`.
+  Writes `item` to the given `device`.
 
-  By default, the `device` is the standard output.
+  By default the `device` is the standard output.
+  It returns `:ok` if it succeeds.
 
   ## Examples
 
-      IO.write("sample")
+      IO.write "sample"
       #=> sample
 
-      IO.write(:stderr, "error")
+      IO.write :stderr, "error"
       #=> error
 
   """
-  @spec write(device, chardata | String.Chars.t()) :: :ok
-  def write(device \\ :stdio, chardata) do
-    :io.put_chars(map_dev(device), to_chardata(chardata))
+  @spec write(device, chardata | String.Chars.t) :: :ok
+  def write(device \\ :stdio, item) do
+    :io.put_chars map_dev(device), to_chardata(item)
   end
 
   @doc """
-  Writes `iodata` to the given `device`.
+  Writes `item` as a binary to the given `device`.
+  No Unicode conversion happens.
+  The operation is Unicode unsafe.
 
-  This operation is meant to be used with "raw" devices
-  that are started without an encoding. The given `iodata`
-  is written as is to the device, without conversion. For
-  more information on IO data, see the "IO data" section in
-  the module documentation.
+  Check `write/2` for more information.
 
-  Use `write/2` for devices with encoding.
-
-  Important: do **not** use this function on IO devices in
-  Unicode mode as it will write the wrong data. In particular,
-  the standard IO device is set to Unicode by default, so writing
-  to stdio with this function will likely result in the wrong data
-  being sent down the wire.
+  Note: do not use this function on IO devices in Unicode mode
+  as it will return the wrong result.
   """
   @spec binwrite(device, iodata) :: :ok | {:error, term}
-  def binwrite(device \\ :stdio, iodata) when is_iodata(iodata) do
-    :file.write(map_dev(device), iodata)
+  def binwrite(device \\ :stdio, item) when is_iodata(item) do
+    :file.write map_dev(device), item
   end
 
   @doc """
   Writes `item` to the given `device`, similar to `write/2`,
   but adds a newline at the end.
-
-  By default, the `device` is the standard output. It returns `:ok`
-  if it succeeds.
-
-  ## Examples
-
-      IO.puts("Hello World!")
-      #=> Hello World!
-
-      IO.puts(:stderr, "error")
-      #=> error
-
   """
-  @spec puts(device, chardata | String.Chars.t()) :: :ok
+  @spec puts(device, chardata | String.Chars.t) :: :ok
   def puts(device \\ :stdio, item) do
-    :io.put_chars(map_dev(device), [to_chardata(item), ?\n])
+    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
   end
 
   @doc """
@@ -309,29 +196,18 @@ defmodule IO do
   ## Examples
 
       stacktrace = [{MyApp, :main, 1, [file: 'my_app.ex', line: 4]}]
-      IO.warn("variable bar is unused", stacktrace)
+      IO.warn "variable bar is unused", stacktrace
       #=> warning: variable bar is unused
       #=>   my_app.ex:4: MyApp.main/1
 
   """
-  @spec warn(chardata | String.Chars.t(), Exception.stacktrace()) :: :ok
+  @spec warn(chardata | String.Chars.t, Exception.stacktrace) :: :ok
   def warn(message, []) do
-    message = [to_chardata(message), ?\n]
-    :elixir_errors.io_warn(0, nil, message, message)
+    :elixir_errors.warn([to_chardata(message), ?\n])
   end
-
-  def warn(message, [{_, _, _, opts} | _] = stacktrace) do
-    message = to_chardata(message)
-    formatted_trace = Enum.map_join(stacktrace, "\n  ", &Exception.format_stacktrace_entry(&1))
-    line = opts[:line]
-    file = opts[:file]
-
-    :elixir_errors.io_warn(
-      line || 0,
-      file && List.to_string(file),
-      message,
-      [message, ?\n, "  ", formatted_trace, ?\n]
-    )
+  def warn(message, stacktrace) when is_list(stacktrace) do
+    formatted = Enum.map_join(stacktrace, "\n  ", &Exception.format_stacktrace_entry(&1))
+    :elixir_errors.warn([to_chardata(message), ?\n, "  ", formatted, ?\n])
   end
 
   @doc """
@@ -341,12 +217,12 @@ defmodule IO do
 
   ## Examples
 
-      IO.warn("variable bar is unused")
+      IO.warn "variable bar is unused"
       #=> warning: variable bar is unused
       #=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4
 
   """
-  @spec warn(chardata | String.Chars.t()) :: :ok
+  @spec warn(chardata | String.Chars.t) :: :ok
   def warn(message) do
     {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
     warn(message, Enum.drop(stacktrace, 2))
@@ -372,7 +248,7 @@ defmodule IO do
 
   ## Examples
 
-      IO.inspect(<<0, 1, 2>>, width: 40)
+      IO.inspect <<0, 1, 2>>, width: 40
 
   Prints:
 
@@ -380,7 +256,7 @@ defmodule IO do
 
   We can use the `:label` option to decorate the output:
 
-      IO.inspect(1..100, label: "a wonderful range")
+      IO.inspect 1..100, label: "a wonderful range"
 
   Prints:
 
@@ -392,7 +268,7 @@ defmodule IO do
       |> IO.inspect(label: "before")
       |> Enum.map(&(&1 * 2))
       |> IO.inspect(label: "after")
-      |> Enum.sum()
+      |> Enum.sum
 
   Prints:
 
@@ -400,9 +276,9 @@ defmodule IO do
       after: [2, 4, 6]
 
   """
-  @spec inspect(item, keyword) :: item when item: var
+  @spec inspect(item, Keyword.t) :: item when item: var
   def inspect(item, opts \\ []) do
-    inspect(:stdio, item, opts)
+    inspect :stdio, item, opts
   end
 
   @doc """
@@ -410,13 +286,12 @@ defmodule IO do
 
   See `inspect/2` for a full list of options.
   """
-  @spec inspect(device, item, keyword) :: item when item: var
+  @spec inspect(device, item, Keyword.t) :: item when item: var
   def inspect(device, item, opts) when is_list(opts) do
-    label = if label = opts[:label], do: [to_chardata(label), ": "], else: []
-    opts = struct(Inspect.Opts, opts)
-    doc = Inspect.Algebra.group(Inspect.Algebra.to_doc(item, opts))
-    chardata = Inspect.Algebra.format(doc, opts.width)
-    puts(device, [label, chardata])
+    label    = if (label = opts[:label]), do: [to_chardata(label), ": "], else: []
+    opts     = struct(Inspect.Opts, opts)
+    chardata = Inspect.Algebra.format(Inspect.Algebra.to_doc(item, opts), opts.width)
+    puts device, [label, chardata]
     item
   end
 
@@ -424,14 +299,14 @@ defmodule IO do
   Gets a number of bytes from IO device `:stdio`.
 
   If `:stdio` is a Unicode device, `count` implies
-  the number of Unicode code points to be retrieved.
+  the number of Unicode codepoints to be retrieved.
   Otherwise, `count` is the number of raw bytes to be retrieved.
 
   See `IO.getn/3` for a description of return values.
 
   """
-  @spec getn(chardata | String.Chars.t(), pos_integer) :: chardata | nodata
-  @spec getn(device, chardata | String.Chars.t()) :: chardata | nodata
+  @spec getn(chardata | String.Chars.t, pos_integer) :: chardata | nodata
+  @spec getn(device, chardata | String.Chars.t) :: chardata | nodata
   def getn(prompt, count \\ 1)
 
   def getn(prompt, count) when is_integer(count) and count > 0 do
@@ -446,7 +321,7 @@ defmodule IO do
   Gets a number of bytes from the IO `device`.
 
   If the IO `device` is a Unicode device, `count` implies
-  the number of Unicode code points to be retrieved.
+  the number of Unicode codepoints to be retrieved.
   Otherwise, `count` is the number of raw bytes to be retrieved.
 
   It returns:
@@ -460,7 +335,7 @@ defmodule IO do
       NFS volume
 
   """
-  @spec getn(device, chardata | String.Chars.t(), pos_integer) :: chardata | nodata
+  @spec getn(device, chardata | String.Chars.t, pos_integer) :: chardata | nodata
   def getn(device, prompt, count) when is_integer(count) and count > 0 do
     :io.get_chars(map_dev(device), to_chardata(prompt), count)
   end
@@ -483,10 +358,10 @@ defmodule IO do
 
   To display "What is your name?" as a prompt and await user input:
 
-      IO.gets("What is your name?\n")
+      IO.gets "What is your name?\n"
 
   """
-  @spec gets(device, chardata | String.Chars.t()) :: chardata | nodata
+  @spec gets(device, chardata | String.Chars.t) :: chardata | nodata
   def gets(device \\ :stdio, prompt) do
     :io.get_line(map_dev(device), to_chardata(prompt))
   end
@@ -512,10 +387,10 @@ defmodule IO do
   Here is an example on how we mimic an echo server
   from the command line:
 
-      Enum.each(IO.stream(:stdio, :line), &IO.write(&1))
+      Enum.each IO.stream(:stdio, :line), &IO.write(&1)
 
   """
-  @spec stream(device, :line | pos_integer) :: Enumerable.t()
+  @spec stream(device, :line | pos_integer) :: Enumerable.t
   def stream(device, line_or_codepoints)
       when line_or_codepoints == :line
       when is_integer(line_or_codepoints) and line_or_codepoints > 0 do
@@ -540,7 +415,7 @@ defmodule IO do
   mode as it will return the wrong result.
 
   """
-  @spec binstream(device, :line | pos_integer) :: Enumerable.t()
+  @spec binstream(device, :line | pos_integer) :: Enumerable.t
   def binstream(device, line_or_bytes)
       when line_or_bytes == :line
       when is_integer(line_or_bytes) and line_or_bytes > 0 do
@@ -548,10 +423,8 @@ defmodule IO do
   end
 
   @doc """
-  Converts chardata into a string.
-
-  For more information about chardata, see the ["Chardata"](#module-chardata)
-  section in the module documentation.
+  Converts chardata (a list of integers representing codepoints,
+  lists and strings) into a string.
 
   In case the conversion fails, it raises an `UnicodeConversionError`.
   If a string is given, it returns the string itself.
@@ -568,7 +441,7 @@ defmodule IO do
       "string"
 
   """
-  @spec chardata_to_string(chardata) :: String.t()
+  @spec chardata_to_string(chardata) :: String.t | no_return
   def chardata_to_string(string) when is_binary(string) do
     string
   end
@@ -578,16 +451,14 @@ defmodule IO do
   end
 
   @doc """
-  Converts IO data into a binary
-
+  Converts iodata (a list of integers representing bytes, lists
+  and binaries) into a binary.
   The operation is Unicode unsafe.
 
-  Notice that this function treats integers in the given IO data as
-  raw bytes and does not perform any kind of encoding conversion.
-  If you want to convert from a charlist to a UTF-8-encoded string,
-  use `chardata_to_string/1` instead. For more information about
-  IO data and chardata, see the ["IO data"](#module-io-data) section in the
-  module documentation.
+  Notice that this function treats lists of integers as raw bytes
+  and does not perform any kind of encoding conversion. If you want
+  to convert from a charlist to a string (UTF-8 encoded), please
+  use `chardata_to_string/1` instead.
 
   If this function receives a binary, the same binary is returned.
 
@@ -607,15 +478,12 @@ defmodule IO do
 
   """
   @spec iodata_to_binary(iodata) :: binary
-  def iodata_to_binary(iodata) do
-    :erlang.iolist_to_binary(iodata)
+  def iodata_to_binary(item) do
+    :erlang.iolist_to_binary(item)
   end
 
   @doc """
-  Returns the size of an IO data.
-
-  For more information about IO data, see the ["IO data"](#module-io-data)
-  section in the module documentation.
+  Returns the size of an iodata.
 
   Inlined by the compiler.
 
@@ -626,8 +494,8 @@ defmodule IO do
 
   """
   @spec iodata_length(iodata) :: non_neg_integer
-  def iodata_length(iodata) do
-    :erlang.iolist_size(iodata)
+  def iodata_length(item) do
+    :erlang.iolist_size(item)
   end
 
   @doc false
@@ -635,10 +503,8 @@ defmodule IO do
     case read(device, line_or_codepoints) do
       :eof ->
         {:halt, device}
-
       {:error, reason} ->
         raise IO.StreamError, reason: reason
-
       data ->
         {[data], device}
     end
@@ -649,10 +515,8 @@ defmodule IO do
     case binread(device, line_or_chars) do
       :eof ->
         {:halt, device}
-
       {:error, reason} ->
         raise IO.StreamError, reason: reason
-
       data ->
         {[data], device}
     end
@@ -661,7 +525,7 @@ defmodule IO do
   @compile {:inline, map_dev: 1, to_chardata: 1}
 
   # Map the Elixir names for standard IO and error to Erlang names
-  defp map_dev(:stdio), do: :standard_io
+  defp map_dev(:stdio),  do: :standard_io
   defp map_dev(:stderr), do: :standard_error
   defp map_dev(other) when is_atom(other) or is_pid(other) or is_tuple(other), do: other
 

lib/elixir/lib/io/ansi.ex

@@ -25,10 +25,9 @@ defmodule IO.ANSI do
 
   import IO.ANSI.Sequence
 
-  @type ansicode :: atom
-  @type ansilist ::
-          maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
-  @type ansidata :: ansilist | ansicode | binary
+  @typep ansicode :: atom
+  @typep ansilist :: maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
+  @type  ansidata :: ansilist | ansicode | binary
 
   @doc """
   Checks if ANSI coloring is supported and enabled on this machine.
@@ -44,7 +43,7 @@ defmodule IO.ANSI do
   end
 
   @doc "Sets foreground color."
-  @spec color(0..255) :: String.t()
+  @spec color(0..255) :: String.t
   def color(code) when code in 0..255, do: "\e[38;5;#{code}m"
 
   @doc ~S"""
@@ -52,13 +51,13 @@ defmodule IO.ANSI do
 
   Valid values for each color are in the range 0 to 5.
   """
-  @spec color(0..5, 0..5, 0..5) :: String.t()
+  @spec color(0..5, 0..5, 0..5) :: String.t
   def color(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color(16 + 36 * r + 6 * g + b)
+    color(16 + (36 * r) + (6 * g) + b)
   end
 
   @doc "Sets background color."
-  @spec color_background(0..255) :: String.t()
+  @spec color_background(0..255) :: String.t
   def color_background(code) when code in 0..255, do: "\e[48;5;#{code}m"
 
   @doc ~S"""
@@ -66,145 +65,118 @@ defmodule IO.ANSI do
 
   Valid values for each color are in the range 0 to 5.
   """
-  @spec color_background(0..5, 0..5, 0..5) :: String.t()
+  @spec color_background(0..5, 0..5, 0..5) :: String.t
   def color_background(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color_background(16 + 36 * r + 6 * g + b)
+    color_background(16 + (36 * r) + (6 * g) + b)
   end
 
   @doc "Resets all attributes."
-  defsequence(:reset, 0)
+  defsequence :reset, 0
 
   @doc "Bright (increased intensity) or bold."
-  defsequence(:bright, 1)
+  defsequence :bright, 1
 
   @doc "Faint (decreased intensity). Not widely supported."
-  defsequence(:faint, 2)
+  defsequence :faint, 2
 
   @doc "Italic: on. Not widely supported. Sometimes treated as inverse."
-  defsequence(:italic, 3)
+  defsequence :italic, 3
 
   @doc "Underline: single."
-  defsequence(:underline, 4)
+  defsequence :underline, 4
 
   @doc "Blink: slow. Less than 150 per minute."
-  defsequence(:blink_slow, 5)
+  defsequence :blink_slow, 5
 
   @doc "Blink: rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported."
-  defsequence(:blink_rapid, 6)
+  defsequence :blink_rapid, 6
 
   @doc "Image: negative. Swap foreground and background."
-  defsequence(:inverse, 7)
+  defsequence :inverse, 7
 
   @doc "Image: negative. Swap foreground and background."
-  defsequence(:reverse, 7)
+  defsequence :reverse, 7
 
   @doc "Conceal. Not widely supported."
-  defsequence(:conceal, 8)
+  defsequence :conceal, 8
 
   @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported."
-  defsequence(:crossed_out, 9)
+  defsequence :crossed_out, 9
 
   @doc "Sets primary (default) font."
-  defsequence(:primary_font, 10)
+  defsequence :primary_font, 10
 
   for font_n <- [1, 2, 3, 4, 5, 6, 7, 8, 9] do
     @doc "Sets alternative font #{font_n}."
-    defsequence(:"font_#{font_n}", font_n + 10)
+    defsequence :"font_#{font_n}", font_n + 10
   end
 
   @doc "Normal color or intensity."
-  defsequence(:normal, 22)
+  defsequence :normal, 22
 
   @doc "Not italic."
-  defsequence(:not_italic, 23)
+  defsequence :not_italic, 23
 
   @doc "Underline: none."
-  defsequence(:no_underline, 24)
+  defsequence :no_underline, 24
 
   @doc "Blink: off."
-  defsequence(:blink_off, 25)
+  defsequence :blink_off, 25
 
   @doc "Image: positive. Normal foreground and background."
-  defsequence(:inverse_off, 27)
+  defsequence :inverse_off, 27
 
   @doc "Image: positive. Normal foreground and background."
-  defsequence(:reverse_off, 27)
+  defsequence :reverse_off, 27
 
   colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
 
   for {color, code} <- Enum.with_index(colors) do
     @doc "Sets foreground color to #{color}."
-    defsequence(color, code + 30)
+    defsequence color, code + 30
 
     @doc "Sets foreground color to light #{color}."
-    defsequence(:"light_#{color}", code + 90)
+    defsequence :"light_#{color}", code + 90
 
     @doc "Sets background color to #{color}."
-    defsequence(:"#{color}_background", code + 40)
+    defsequence :"#{color}_background", code + 40
 
     @doc "Sets background color to light #{color}."
-    defsequence(:"light_#{color}_background", code + 100)
+    defsequence :"light_#{color}_background", code + 100
   end
 
   @doc "Default text color."
-  defsequence(:default_color, 39)
+  defsequence :default_color, 39
 
   @doc "Default background color."
-  defsequence(:default_background, 49)
+  defsequence :default_background, 49
 
   @doc "Framed."
-  defsequence(:framed, 51)
+  defsequence :framed, 51
 
   @doc "Encircled."
-  defsequence(:encircled, 52)
+  defsequence :encircled, 52
 
   @doc "Overlined."
-  defsequence(:overlined, 53)
+  defsequence :overlined, 53
 
   @doc "Not framed or encircled."
-  defsequence(:not_framed_encircled, 54)
+  defsequence :not_framed_encircled, 54
 
   @doc "Not overlined."
-  defsequence(:not_overlined, 55)
+  defsequence :not_overlined, 55
 
   @doc "Sends cursor home."
-  defsequence(:home, "", "H")
-
-  @doc """
-  Sends cursor to the absolute position specified by `line` and `column`.
-
-  Line `0` and column `0` would mean the top left corner.
-  """
-  @spec cursor(non_neg_integer, non_neg_integer) :: String.t()
-  def cursor(line, column)
-      when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
-    "\e[#{line};#{column}H"
-  end
-
-  @doc "Sends cursor `lines` up."
-  @spec cursor_up(pos_integer) :: String.t()
-  def cursor_up(lines \\ 1) when is_integer(lines) and lines >= 1, do: "\e[#{lines}A"
-
-  @doc "Sends cursor `lines` down."
-  @spec cursor_down(pos_integer) :: String.t()
-  def cursor_down(lines \\ 1) when is_integer(lines) and lines >= 1, do: "\e[#{lines}B"
-
-  @doc "Sends cursor `columns` to the right."
-  @spec cursor_right(pos_integer) :: String.t()
-  def cursor_right(columns \\ 1) when is_integer(columns) and columns >= 1, do: "\e[#{columns}C"
-
-  @doc "Sends cursor `columns` to the left."
-  @spec cursor_left(pos_integer) :: String.t()
-  def cursor_left(columns \\ 1) when is_integer(columns) and columns >= 1, do: "\e[#{columns}D"
+  defsequence :home, "", "H"
 
   @doc "Clears screen."
-  defsequence(:clear, "2", "J")
+  defsequence :clear, "2", "J"
 
   @doc "Clears line."
-  defsequence(:clear_line, "2", "K")
+  defsequence :clear_line, "2", "K"
 
   defp format_sequence(other) do
-    raise ArgumentError, "invalid ANSI sequence specification: #{inspect(other)}"
+    raise ArgumentError, "invalid ANSI sequence specification: #{inspect other}"
   end
 
   @doc ~S"""
@@ -237,7 +209,7 @@ defmodule IO.ANSI do
   The named sequences are represented by atoms.
 
   An optional boolean parameter can be passed to enable or disable
-  emitting actual ANSI codes. When `false`, no ANSI codes will be emitted.
+  emitting actual ANSI codes. When `false`, no ANSI codes will emitted.
   By default checks if ANSI is enabled using the `enabled?/0` function.
 
   ## Examples
@@ -271,7 +243,7 @@ defmodule IO.ANSI do
   end
 
   defp do_format([], [], acc, true, true) do
-    [acc | IO.ANSI.reset()]
+    [acc | IO.ANSI.reset]
   end
 
   defp do_format([], [], acc, _emit?, _append_reset) do

lib/elixir/lib/io/ansi/docs.ex

@@ -7,16 +7,14 @@ defmodule IO.ANSI.Docs do
   @doc """
   The default options used by this module.
 
-  The supported keys are:
+  The supported values are:
 
     * `:enabled`           - toggles coloring on and off (true)
     * `:doc_bold`          - bold text (bright)
     * `:doc_code`          - code blocks (cyan)
     * `:doc_headings`      - h1, h2, h3, h4, h5, h6 headings (yellow)
-    * `:doc_metadata`      - documentation metadata keys (yellow)
-    * `:doc_quote`         - leading quote character `> ` (light black)
     * `:doc_inline_code`   - inline code (cyan)
-    * `:doc_table_heading` - the style for table headings
+    * `:doc_table_heading` - style for table headings
     * `:doc_title`         - top level heading (reverse, yellow)
     * `:doc_underline`     - underlined text (underline)
     * `:width`             - the width to format the text (80)
@@ -24,21 +22,16 @@ defmodule IO.ANSI.Docs do
   Values for the color settings are strings with
   comma-separated ANSI values.
   """
-  @spec default_options() :: keyword
   def default_options do
-    [
-      enabled: true,
-      doc_bold: [:bright],
-      doc_code: [:cyan],
-      doc_headings: [:yellow],
-      doc_metadata: [:yellow],
-      doc_quote: [:light_black],
-      doc_inline_code: [:cyan],
-      doc_table_heading: [:reverse],
-      doc_title: [:reverse, :yellow],
-      doc_underline: [:underline],
-      width: 80
-    ]
+    [enabled:           true,
+     doc_bold:          [:bright],
+     doc_code:          [:cyan],
+     doc_headings:      [:yellow],
+     doc_inline_code:   [:cyan],
+     doc_table_heading: [:reverse],
+     doc_title:         [:reverse, :yellow],
+     doc_underline:     [:underline],
+     width:             80]
   end
 
   @doc """
@@ -46,67 +39,24 @@ defmodule IO.ANSI.Docs do
 
   See `default_options/0` for docs on the supported options.
   """
-  @spec print_heading(String.t(), keyword) :: :ok
   def print_heading(heading, options \\ []) do
-    IO.puts(IO.ANSI.reset())
+    IO.puts IO.ANSI.reset
     options = Keyword.merge(default_options(), options)
-    width = options[:width]
+    width   = options[:width]
     padding = div(width + String.length(heading), 2)
     heading = heading |> String.pad_leading(padding) |> String.pad_trailing(width)
     write(:doc_title, heading, options)
     newline_after_block()
   end
 
-  @doc """
-  Prints documentation metadata (only `delegate_to`, `deprecated`, `guard`, and `since` for now).
-
-  See `default_options/0` for docs on the supported options.
-  """
-  @spec print_metadata(map, keyword) :: :ok
-  def print_metadata(metadata, options \\ []) when is_map(metadata) do
-    options = Keyword.merge(default_options(), options)
-    print_each_metadata(metadata, options) && IO.write("\n")
-  end
-
-  @metadata_filter [:deprecated, :guard, :since]
-
-  defp print_each_metadata(metadata, options) do
-    Enum.reduce(metadata, false, fn
-      {key, value}, _printed when is_binary(value) and key in @metadata_filter ->
-        label = metadata_label(key, options)
-        indent = String.duplicate(" ", length_without_escape(label, 0) + 1)
-        write_with_wrap([label | String.split(value, @spaces)], options[:width], indent, true, "")
-
-      {key, value}, _printed when is_boolean(value) and key in @metadata_filter ->
-        IO.puts([metadata_label(key, options), ' ', to_string(value)])
-
-      {:delegate_to, {m, f, a}}, _printed ->
-        label = metadata_label(:delegate_to, options)
-        IO.puts([label, ' ', Exception.format_mfa(m, f, a)])
-
-      _metadata, printed ->
-        printed
-    end)
-  end
-
-  defp metadata_label(key, options) do
-    if options[:enabled] do
-      "#{color(:doc_metadata, options)}#{key}:#{IO.ANSI.reset()}"
-    else
-      "#{key}:"
-    end
-  end
-
   @doc """
   Prints the documentation body.
 
-  In addition to the printing string, takes a set of `options`
-  defined in `default_options/0`.
+  In addition to the printing string, takes a set of options
+  defined in `default_options/1`.
   """
-  @spec print(String.t(), keyword) :: :ok
   def print(doc, options \\ []) do
     options = Keyword.merge(default_options(), options)
-
     doc
     |> String.split(["\r\n", "\n"], trim: false)
     |> Enum.map(&String.trim_trailing/1)
@@ -120,32 +70,22 @@ defmodule IO.ANSI.Docs do
   defp process(["# " <> _ = heading | rest], text, indent, options) do
     write_heading(heading, rest, text, indent, options)
   end
-
   defp process(["## " <> _ = heading | rest], text, indent, options) do
     write_heading(heading, rest, text, indent, options)
   end
-
   defp process(["### " <> _ = heading | rest], text, indent, options) do
     write_heading(heading, rest, text, indent, options)
   end
-
   defp process(["#### " <> _ = heading | rest], text, indent, options) do
     write_heading(heading, rest, text, indent, options)
   end
-
   defp process(["##### " <> _ = heading | rest], text, indent, options) do
     write_heading(heading, rest, text, indent, options)
   end
-
   defp process(["###### " <> _ = heading | rest], text, indent, options) do
     write_heading(heading, rest, text, indent, options)
   end
 
-  defp process([">" <> line | rest], text, indent, options) do
-    write_text(text, indent, options)
-    process_quote(rest, [line], indent, options)
-  end
-
   defp process(["" | rest], text, indent, options) do
     write_text(text, indent, options)
     process(rest, [], indent, options)
@@ -164,18 +104,15 @@ defmodule IO.ANSI.Docs do
     process_fenced_code_block(rest, text, indent, options, _delimiter = "~~~")
   end
 
-  defp process(all = [line | rest], text, indent, options) do
+  defp process(all=[line | rest], text, indent, options) do
     {stripped, count} = strip_spaces(line, 0, :infinity)
-
     cond do
       link_label?(stripped, count) ->
         write_text([line], indent, options, true)
         process(rest, text, indent, options)
-
       table_line?(stripped) and rest != [] and table_line?(hd(rest)) ->
         write_text(text, indent, options)
         process_table(all, indent, options)
-
       true ->
         process_rest(stripped, rest, count, text, indent, options)
     end
@@ -190,47 +127,6 @@ defmodule IO.ANSI.Docs do
     process(rest, [], "", options)
   end
 
-  ## Quotes
-
-  defp process_quote([], lines, indent, options) do
-    write_quote(lines, indent, options, false)
-  end
-
-  defp process_quote([">", ">" <> line | rest], lines, indent, options) do
-    write_quote(lines, indent, options, true)
-    write_empty_quote_line(options)
-    process_quote(rest, [line], indent, options)
-  end
-
-  defp process_quote([">" <> line | rest], lines, indent, options) do
-    process_quote(rest, [line | lines], indent, options)
-  end
-
-  defp process_quote(rest, lines, indent, options) do
-    write_quote(lines, indent, options, false)
-    process(rest, [], indent, options)
-  end
-
-  defp write_quote(lines, indent, options, no_wrap) do
-    lines
-    |> Enum.map(&String.trim/1)
-    |> Enum.reverse()
-    |> write_lines(
-      indent,
-      options,
-      no_wrap,
-      quote_prefix(options)
-    )
-  end
-
-  defp quote_prefix(options), do: "#{color(:doc_quote, options)}> #{IO.ANSI.reset()}"
-
-  defp write_empty_quote_line(options) do
-    options
-    |> quote_prefix()
-    |> IO.puts()
-  end
-
   ## Lists
 
   defp process_rest(stripped, rest, count, text, indent, options) do
@@ -238,15 +134,12 @@ defmodule IO.ANSI.Docs do
       <<bullet, ?\s, item::binary>> when bullet in @bullets ->
         write_text(text, indent, options)
         process_list("• ", item, rest, count, indent, options)
-
       <<d1, ?., ?\s, item::binary>> when d1 in ?0..?9 ->
         write_text(text, indent, options)
         process_list(<<d1, ?., ?\s>>, item, rest, count, indent, options)
-
       <<d1, d2, ?., ?\s, item::binary>> when d1 in ?0..?9 and d2 in ?0..?9 ->
         write_text(text, indent, options)
         process_list(<<d1, d2, ?., ?\s>>, item, rest, count, indent, options)
-
       _ ->
         process(rest, [stripped | text], indent, options)
     end
@@ -266,7 +159,6 @@ defmodule IO.ANSI.Docs do
 
   defp process_list_next([line | rest], count, max, acc) do
     {stripped, next_count} = strip_spaces(line, 0, max)
-
     case process_list_next_kind(stripped, rest, count, next_count) do
       :next -> process_list_next(rest, count, max, [stripped | acc])
       :done -> {Enum.reverse(acc), [line | rest], true}
@@ -282,20 +174,14 @@ defmodule IO.ANSI.Docs do
     case {stripped, rest} do
       {<<bullet, ?\s, _::binary>>, _} when bullet in @bullets and next_count <= count ->
         :list
-
       {<<d1, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and next_count <= count ->
         :list
-
-      {<<d1, d2, ?., ?\s, _::binary>>, _}
-      when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
+      {<<d1, d2, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
         :list
-
       {"", [" " <> _ | _]} ->
         :next
-
       {"", _} ->
         :done
-
       _ ->
         :next
     end
@@ -315,25 +201,16 @@ defmodule IO.ANSI.Docs do
   end
 
   defp write_text(lines, indent, options, no_wrap) do
-    write_lines(lines, indent, options, no_wrap, "")
-  end
-
-  defp write_lines(lines, indent, options, no_wrap, prefix) do
     lines
     |> Enum.join(" ")
-    |> format_text(options)
+    |> handle_links
+    |> handle_inline(options)
     |> String.split(@spaces)
-    |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap, prefix)
+    |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap)
 
     unless no_wrap, do: newline_after_block()
   end
 
-  defp format_text(text, options) do
-    text
-    |> handle_links()
-    |> handle_inline(options)
-  end
-
   ## Code blocks
 
   defp process_code([], code, indent, options) do
@@ -387,38 +264,35 @@ defmodule IO.ANSI.Docs do
 
   defp table_lines(lines, options) do
     lines = Enum.map(lines, &split_into_columns(&1, options))
-    count = Enum.map(lines, &length/1) |> Enum.max()
+    count = Enum.map(lines, &length/1) |> Enum.max
     lines = Enum.map(lines, &pad_to_number_of_columns(&1, count))
 
     widths =
       for line <- lines do
-        if table_header?(line) do
-          for _ <- line, do: 0
-        else
-          for {_col, length} <- line, do: length
-        end
+        for {_col, length} <- line, do: length
       end
 
-    col_widths = Enum.reduce(widths, List.duplicate(0, count), &max_column_widths/2)
+    col_widths = Enum.reduce(widths,
+                             List.duplicate(0, count),
+                             &max_column_widths/2)
+
     render_table(lines, col_widths, options)
   end
 
   defp split_into_columns(line, options) do
     line
-    |> String.trim(" ")
     |> String.trim("|")
-    |> String.split("|")
+    |> String.trim()
+    |> String.split(" | ")
     |> Enum.map(&render_column(&1, options))
   end
 
   defp render_column(col, options) do
     col =
       col
-      |> String.trim()
       |> String.replace("\\\|", "|")
       |> handle_links
       |> handle_inline(options)
-
     {col, length_without_escape(col, 0)}
   end
 
@@ -431,10 +305,7 @@ defmodule IO.ANSI.Docs do
   # If second line is heading separator, use the heading style on the first
   defp render_table([first, second | rest], widths, options) do
     combined = Enum.zip(first, widths)
-
     if table_header?(second) do
-      alignments = Enum.map(second, &column_alignment/1)
-      options = Keyword.put_new(options, :alignments, alignments)
       draw_table_row(combined, options, :heading)
       render_table(rest, widths, options)
     else
@@ -449,65 +320,36 @@ defmodule IO.ANSI.Docs do
     render_table(rest, widths, options)
   end
 
-  defp render_table([], _, _), do: nil
+  defp render_table([], _, _),
+    do: nil
 
-  defp column_alignment({line, _}) do
-    cond do
-      String.starts_with?(line, ":") and String.ends_with?(line, ":") -> :center
-      String.ends_with?(line, ":") -> :right
-      true -> :left
-    end
+  defp table_header?(row) do
+    Enum.all?(row, fn {col, _} -> table_header_column?(col) end)
   end
 
-  defp table_header?(line) do
-    Enum.all?(line, fn {col, _} -> table_header_column?(col) end)
-  end
+  defp table_header_column?(":" <> row), do: table_header_contents?(row)
+  defp table_header_column?(row), do: table_header_contents?(row)
 
-  defp table_header_column?(":" <> rest), do: table_header_contents?(rest)
-  defp table_header_column?(col), do: table_header_contents?(col)
-
-  defp table_header_contents?("-" <> rest), do: table_header_contents?(rest)
+  defp table_header_contents?("-" <> row), do: table_header_contents?(row)
   defp table_header_contents?(":"), do: true
   defp table_header_contents?(""), do: true
   defp table_header_contents?(_), do: false
 
   defp draw_table_row(cols_and_widths, options, heading \\ false) do
-    default_alignments = List.duplicate(:left, length(cols_and_widths))
-    alignments = Keyword.get(options, :alignments, default_alignments)
-
     columns =
-      cols_and_widths
-      |> Enum.zip(alignments)
-      |> Enum.map_join(" | ", &generate_table_cell/1)
+      Enum.map_join(cols_and_widths, " | ", fn {{col, length}, width} ->
+        col <> String.duplicate(" ", width - length)
+      end)
 
     if heading do
       write(:doc_table_heading, columns, options)
     else
-      IO.puts(columns)
+      IO.puts columns
     end
   end
 
-  defp generate_table_cell({{{col, length}, width}, :center}) do
-    ansi_diff = byte_size(col) - length
-    width = width + ansi_diff
-
-    col
-    |> String.pad_leading(div(width, 2) - div(length, 2) + length)
-    |> String.pad_trailing(width + 1 - rem(width, 2))
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :right}) do
-    ansi_diff = byte_size(col) - length
-    String.pad_leading(col, width + ansi_diff)
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :left}) do
-    ansi_diff = byte_size(col) - length
-    String.pad_trailing(col, width + ansi_diff)
-  end
-
   defp table_line?(line) do
-    line =~ ~r/[:\ -]\|[:\ -]/
+    line =~ " | "
   end
 
   ## Helpers
@@ -520,34 +362,23 @@ defmodule IO.ANSI.Docs do
   defp link_label?(""), do: false
   defp link_label?(<<_>> <> rest), do: link_label?(rest)
 
-  defp strip_spaces(" " <> line, acc, max) when acc < max, do: strip_spaces(line, acc + 1, max)
-  defp strip_spaces(rest, acc, _max), do: {rest, acc}
+  defp strip_spaces(" " <> line, acc, max) when acc < max,
+    do: strip_spaces(line, acc + 1, max)
+  defp strip_spaces(rest, acc, _max),
+    do: {rest, acc}
 
   defp write(style, string, options) do
-    IO.puts([color(style, options), string, IO.ANSI.reset()])
+    IO.puts [color(style, options), string, IO.ANSI.reset]
   end
 
-  defp write_with_wrap([], _available, _indent, _first, _prefix) do
+  defp write_with_wrap([], _available, _indent, _first) do
     :ok
   end
 
-  defp write_with_wrap(words, available, indent, first, prefix) do
-    words
-    |> wrap_text(available, indent, first, prefix, [])
-    |> Enum.join("\n")
-    |> IO.puts()
-  end
-
-  defp wrap_text([], _available, _indent, _first, _prefix, wrapped_lines) do
-    Enum.reverse(wrapped_lines)
-  end
-
-  defp wrap_text(words, available, indent, first, prefix, wrapped_lines) do
-    prefix_length = length_without_escape(prefix, 0)
-    {words, rest} = take_words(words, available - prefix_length, [])
-    line = [if(first, do: "", else: indent), prefix, Enum.join(words, " ")]
-
-    wrap_text(rest, available, indent, false, prefix, [line | wrapped_lines])
+  defp write_with_wrap(words, available, indent, first) do
+    {words, rest} = take_words(words, available, [])
+    IO.puts (if first, do: "", else: indent) <> Enum.join(words, " ")
+    write_with_wrap(rest, available, indent, false)
   end
 
   defp take_words([word | words], available, acc) do
@@ -594,20 +425,22 @@ defmodule IO.ANSI.Docs do
   end
 
   defp escape_underlines_in_link(text) do
-    # Regular expression adapted from https://tools.ietf.org/html/rfc3986#appendix-B
-    Regex.replace(~r{[a-z][a-z0-9\+\-\.]*://\S*}i, text, &String.replace(&1, "_", "\\_"))
+    ~r{https?\S*}
+    |> Regex.recompile!
+    |> Regex.replace(text, &String.replace(&1, "_", "\\_"))
   end
 
   defp remove_square_brackets_in_link(text) do
-    Regex.replace(~r{\[([^\]]*?)\]\((.*?)\)}, text, "\\1 (\\2)")
+    ~r{\[(.*?)\]\((.*?)\)}
+    |> Regex.recompile!
+    |> Regex.replace(text, "\\1 (\\2)")
   end
 
   # We have four entries: **, *, _ and `.
   #
   # The first three behave the same while the last one is simpler
-  # when it comes to delimiters as it ignores spaces and escape
-  # characters. But, since the first has two characters, we need to
-  # handle 3 cases:
+  # when it comes to delimiters. But, since the first has two
+  # characters, we need to handle 3 cases:
   #
   # 1. **
   # 2. _ and *
@@ -618,8 +451,7 @@ defmodule IO.ANSI.Docs do
 
   # Characters that can mark the beginning or the end of a word.
   # Only support the most common ones at this moment.
-  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&] ++
-                [?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
+  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&, ?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
 
   # Inline start
 
@@ -638,29 +470,29 @@ defmodule IO.ANSI.Docs do
   # Inline delimiters
 
   defp handle_inline(<<delimiter, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and delimiter in @delimiters do
+      when rest != "" and delimiter in @delimiters do
     handle_inline(rest, ?d, ["**"], [delimiter, Enum.reverse(buffer) | acc], options)
   end
 
   defp handle_inline(<<delimiter, mark, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and delimiter in @delimiters and mark in @single do
+      when rest != "" and delimiter in @delimiters and mark in @single do
     handle_inline(rest, mark, [<<mark>>], [delimiter, Enum.reverse(buffer) | acc], options)
   end
 
   defp handle_inline(<<?`, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" do
+      when rest != "" do
     handle_inline(rest, ?`, ["`"], [Enum.reverse(buffer) | acc], options)
   end
 
   # Clauses for handling escape
 
   defp handle_inline(<<?\\, ?\\, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" do
+      when rest != "" do
     handle_inline(rest, ?d, ["**"], [?\\, Enum.reverse(buffer) | acc], options)
   end
 
   defp handle_inline(<<?\\, ?\\, mark, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and mark in @single do
+      when rest != "" and mark in @single do
     handle_inline(rest, mark, [<<mark>>], [?\\, Enum.reverse(buffer) | acc], options)
   end
 
@@ -669,31 +501,30 @@ defmodule IO.ANSI.Docs do
   end
 
   # An escape is not valid inside `
-  defp handle_inline(<<?\\, mark, rest::binary>>, limit, buffer, acc, options) when limit != ?` do
+  defp handle_inline(<<?\\, mark, rest::binary>>, limit, buffer, acc, options)
+      when not(mark == limit and mark == ?`) do
     handle_inline(rest, limit, [mark | buffer], acc, options)
   end
 
   # Inline end
 
   defp handle_inline(<<?*, ?*, delimiter, rest::binary>>, ?d, buffer, acc, options)
-       when delimiter in @delimiters do
-    inline_buffer = inline_buffer(buffer, options)
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer | acc], options)
+      when delimiter in @delimiters do
+    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
   defp handle_inline(<<mark, delimiter, rest::binary>>, mark, buffer, acc, options)
-       when delimiter in @delimiters and mark in @single do
-    inline_buffer = inline_buffer(buffer, options)
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer | acc], options)
+      when delimiter in @delimiters and mark in @single do
+    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
   defp handle_inline(<<?*, ?*, rest::binary>>, ?d, buffer, acc, options)
-       when rest == "" do
+      when rest == "" do
     handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
   defp handle_inline(<<mark, rest::binary>>, mark, buffer, acc, options)
-       when rest == "" and mark in @single do
+      when rest == "" and mark in @single do
     handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
@@ -708,19 +539,19 @@ defmodule IO.ANSI.Docs do
   end
 
   defp handle_inline(<<>>, _mark, buffer, acc, _options) do
-    IO.iodata_to_binary(Enum.reverse([Enum.reverse(buffer) | acc]))
+    IO.iodata_to_binary Enum.reverse([Enum.reverse(buffer) | acc])
   end
 
   defp inline_buffer(buffer, options) do
-    [h | t] = Enum.reverse([IO.ANSI.reset() | buffer])
+    [h | t] = Enum.reverse([IO.ANSI.reset | buffer])
     [color_for(h, options) | t]
   end
 
   defp color_for(mark, colors) do
     case mark do
-      "`" -> color(:doc_inline_code, colors)
-      "_" -> color(:doc_underline, colors)
-      "*" -> color(:doc_bold, colors)
+      "`"  -> color(:doc_inline_code, colors)
+      "_"  -> color(:doc_underline, colors)
+      "*"  -> color(:doc_bold, colors)
       "**" -> color(:doc_bold, colors)
     end
   end
@@ -730,5 +561,5 @@ defmodule IO.ANSI.Docs do
     IO.ANSI.format_fragment(color, colors[:enabled])
   end
 
-  defp newline_after_block, do: IO.puts(IO.ANSI.reset())
+  defp newline_after_block, do: IO.puts(IO.ANSI.reset)
 end

lib/elixir/lib/io/stream.ex

@@ -1,9 +1,8 @@
 defmodule IO.StreamError do
   defexception [:reason, :message]
 
-  @impl true
   def exception(opts) do
-    reason = opts[:reason]
+    reason    = opts[:reason]
     formatted = IO.iodata_to_binary(:file.format_error(reason))
     %IO.StreamError{message: "error during streaming: #{formatted}", reason: reason}
   end
@@ -17,7 +16,7 @@ defmodule IO.Stream do
 
     * `device`        - the IO device
     * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given number of bytes
+    * `line_or_bytes` - if reading should read lines or a given amount of bytes
 
   It is worth noting that an IO stream has side effects and every time you go
   over the stream you may get different results.
@@ -42,12 +41,10 @@ defmodule IO.Stream do
       fn
         :ok, {:cont, x} ->
           case raw do
-            true -> IO.binwrite(device, x)
+            true  -> IO.binwrite(device, x)
             false -> IO.write(device, x)
           end
-
-        :ok, _ ->
-          stream
+        :ok, _ -> stream
       end
     end
   end
@@ -56,11 +53,10 @@ defmodule IO.Stream do
     def reduce(%{device: device, raw: raw, line_or_bytes: line_or_bytes}, acc, fun) do
       next_fun =
         case raw do
-          true -> &IO.each_binstream(&1, line_or_bytes)
+          true  -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
-
-      Stream.resource(fn -> device end, next_fun, & &1).(acc, fun)
+      Stream.resource(fn -> device end, next_fun, &(&1)).(acc, fun)
     end
 
     def count(_stream) do
@@ -70,9 +66,5 @@ defmodule IO.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
-
-    def slice(_stream) do
-      {:error, __MODULE__}
-    end
   end
 end

lib/elixir/lib/kernel/cli.ex

@@ -1,20 +1,9 @@
 defmodule Kernel.CLI do
   @moduledoc false
 
-  @compile {:no_warn_undefined, [Logger, IEx]}
-
-  @blank_config %{
-    commands: [],
-    output: ".",
-    compile: [],
-    no_halt: false,
-    compiler_options: [],
-    errors: [],
-    pa: [],
-    pz: [],
-    verbose_compile: false,
-    profile: nil
-  }
+  @blank_config %{commands: [], output: ".", compile: [],
+                  halt: true, compiler_options: [], errors: [],
+                  pa: [], pz: [], verbose_compile: false}
 
   @doc """
   This is the API invoked by Elixir boot process.
@@ -24,18 +13,15 @@ defmodule Kernel.CLI do
 
     {config, argv} = parse_argv(argv)
     System.argv(argv)
-    System.no_halt(config.no_halt)
 
-    fun = fn _ ->
+    run fn _ ->
       errors = process_commands(config)
 
       if errors != [] do
         Enum.each(errors, &IO.puts(:stderr, &1))
         System.halt(1)
       end
-    end
-
-    run(fun)
+    end, config.halt
   end
 
   @doc """
@@ -46,10 +32,9 @@ defmodule Kernel.CLI do
   This function is used by Elixir's CLI and also
   by escripts generated by Elixir.
   """
-  def run(fun) do
+  def run(fun, halt \\ true) do
     {ok_or_shutdown, status} = exec_fun(fun, {:ok, 0})
-
-    if ok_or_shutdown == :shutdown or not System.no_halt() do
+    if ok_or_shutdown == :shutdown or halt do
       {_, status} = at_exit({ok_or_shutdown, status})
 
       # Ensure Logger messages are flushed before halting
@@ -62,51 +47,18 @@ defmodule Kernel.CLI do
     end
   end
 
-  @doc """
-  Parses the CLI arguments. Made public for testing.
-  """
+  @doc false
   def parse_argv(argv) do
     parse_argv(argv, @blank_config)
   end
 
-  @doc """
-  Process CLI commands. Made public for testing.
-  """
+  @doc false
   def process_commands(config) do
     results = Enum.map(Enum.reverse(config.commands), &process_command(&1, config))
-    errors = for {:error, msg} <- results, do: msg
+    errors  = for {:error, msg} <- results, do: msg
     Enum.reverse(config.errors, errors)
   end
 
-  @doc """
-  Shared helper for error formatting on CLI tools.
-  """
-  def format_error(kind, reason, stacktrace) do
-    {blamed, stacktrace} = Exception.blame(kind, reason, stacktrace)
-
-    iodata =
-      case blamed do
-        %FunctionClauseError{} ->
-          formatted = Exception.format_banner(kind, reason, stacktrace)
-          padded_blame = pad(FunctionClauseError.blame(blamed, &inspect/1, &blame_match/2))
-          [formatted, padded_blame]
-
-        _ ->
-          Exception.format_banner(kind, blamed, stacktrace)
-      end
-
-    [iodata, ?\n, Exception.format_stacktrace(prune_stacktrace(stacktrace))]
-  end
-
-  @doc """
-  Function invoked across nodes for `--rpc-eval`.
-  """
-  def rpc_eval(expr) do
-    wrapper(fn -> Code.eval_string(expr) end)
-  catch
-    kind, reason -> {kind, reason, __STACKTRACE__}
-  end
-
   ## Helpers
 
   defp at_exit(res) do
@@ -124,23 +76,22 @@ defmodule Kernel.CLI do
           fun.(elem(res, 1))
         catch
           :exit, {:shutdown, int} when is_integer(int) ->
-            send(parent, {self(), {:shutdown, int}})
+            send parent, {self(), {:shutdown, int}}
             exit({:shutdown, int})
-
           :exit, reason
-          when reason == :normal
-          when reason == :shutdown
-          when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown ->
-            send(parent, {self(), {:shutdown, 0}})
+              when reason == :normal
+              when reason == :shutdown
+              when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown ->
+            send parent, {self(), {:shutdown, 0}}
             exit(reason)
-
           kind, reason ->
-            print_error(kind, reason, __STACKTRACE__)
-            send(parent, {self(), {:shutdown, 1}})
-            exit(to_exit(kind, reason, __STACKTRACE__))
+            stack = System.stacktrace
+            print_error(kind, reason, stack)
+            send parent, {self(), {:shutdown, 1}}
+            exit(to_exit(kind, reason, stack))
         else
           _ ->
-            send(parent, {self(), res})
+            send parent, {self(), res}
         end
       end)
 
@@ -148,7 +99,6 @@ defmodule Kernel.CLI do
       {^pid, res} ->
         :erlang.demonitor(ref, [:flush])
         res
-
       {:DOWN, ^ref, _, _, other} ->
         print_error({:EXIT, pid}, other, [])
         {:shutdown, 1}
@@ -164,39 +114,18 @@ defmodule Kernel.CLI do
       {[h | hs], _} when h == hd(list) ->
         new_config = %{config | errors: ["#{h} : Unknown option" | config.errors]}
         callback.(hs, new_config)
-
       {new_list, new_config} ->
         callback.(new_list, new_config)
     end
   end
 
-  ## Error handling
-
-  defp print_error(kind, reason, stacktrace) do
-    IO.write(:stderr, format_error(kind, reason, stacktrace))
+  defp print_error(kind, reason, trace) do
+    IO.puts :stderr, Exception.format(kind, reason, prune_stacktrace(trace))
   end
 
-  defp blame_match(%{match?: true, node: node}, _), do: blame_ansi(:normal, "+", node)
-  defp blame_match(%{match?: false, node: node}, _), do: blame_ansi(:red, "-", node)
-  defp blame_match(_, string), do: string
-
-  defp blame_ansi(color, no_ansi, node) do
-    if IO.ANSI.enabled?() do
-      [color | Macro.to_string(node)]
-      |> IO.ANSI.format(true)
-      |> IO.iodata_to_binary()
-    else
-      no_ansi <> Macro.to_string(node) <> no_ansi
-    end
-  end
-
-  defp pad(string) do
-    "    " <> String.replace(string, "\n", "\n    ")
-  end
-
-  @elixir_internals [:elixir, :elixir_aliases, :elixir_expand, :elixir_compiler, :elixir_module] ++
-                      [:elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map] ++
-                      [:elixir_erl, :elixir_erl_clauses, :elixir_erl_pass, Kernel.ErrorHandler]
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
+                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
+                     :elixir_def, :elixir_map]
 
   defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
     prune_stacktrace(t)
@@ -217,73 +146,64 @@ defmodule Kernel.CLI do
   # Parse shared options
 
   defp parse_shared([opt | _t], _config) when opt in ["-v", "--version"] do
-    if function_exported?(IEx, :started?, 0) and IEx.started?() do
-      IO.puts("IEx " <> System.build_info()[:build])
+    if function_exported?(IEx, :started?, 0) and IEx.started? do
+      IO.puts "IEx " <> System.build_info[:build]
     else
-      IO.puts(:erlang.system_info(:system_version))
-      IO.puts("Elixir " <> System.build_info()[:build])
+      IO.puts :erlang.system_info(:system_version)
+      IO.puts "Elixir " <> System.build_info[:build]
     end
 
-    System.halt(0)
+    System.halt 0
   end
 
   defp parse_shared(["-pa", h | t], config) do
     paths = expand_code_path(h)
     Enum.each(paths, &:code.add_patha/1)
-    parse_shared(t, %{config | pa: config.pa ++ paths})
+    parse_shared t, %{config | pa: config.pa ++ paths}
   end
 
   defp parse_shared(["-pz", h | t], config) do
     paths = expand_code_path(h)
     Enum.each(paths, &:code.add_pathz/1)
-    parse_shared(t, %{config | pz: config.pz ++ paths})
+    parse_shared t, %{config | pz: config.pz ++ paths}
   end
 
   defp parse_shared(["--app", h | t], config) do
-    parse_shared(t, %{config | commands: [{:app, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:app, h} | config.commands]}
   end
 
   defp parse_shared(["--no-halt" | t], config) do
-    parse_shared(t, %{config | no_halt: true})
+    parse_shared t, %{config | halt: false}
   end
 
   defp parse_shared(["-e", h | t], config) do
-    parse_shared(t, %{config | commands: [{:eval, h} | config.commands]})
-  end
-
-  defp parse_shared(["--eval", h | t], config) do
-    parse_shared(t, %{config | commands: [{:eval, h} | config.commands]})
-  end
-
-  defp parse_shared(["--rpc-eval", node, h | t], config) do
-    node = append_hostname(node)
-    parse_shared(t, %{config | commands: [{:rpc_eval, node, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:eval, h} | config.commands]}
   end
 
   defp parse_shared(["-r", h | t], config) do
-    parse_shared(t, %{config | commands: [{:require, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:require, h} | config.commands]}
   end
 
   defp parse_shared(["-pr", h | t], config) do
-    parse_shared(t, %{config | commands: [{:parallel_require, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:parallel_require, h} | config.commands]}
+  end
+
+  defp parse_shared([erl, _ | t], config) when erl in ["--erl", "--sname", "--name", "--cookie", "--logger-otp-reports", "--logger-sasl-reports"] do
+    parse_shared t, config
+  end
+
+  defp parse_shared([erl | t], config) when erl in ["--detached", "--hidden", "--werl"] do
+    parse_shared t, config
   end
 
   defp parse_shared(list, config) do
     {list, config}
   end
 
-  defp append_hostname(node) do
-    case :string.find(node, "@") do
-      :nomatch -> node <> :string.find(Atom.to_string(node()), "@")
-      _ -> node
-    end
-  end
-
   defp expand_code_path(path) do
     path = Path.expand(path)
-
     case Path.wildcard(path) do
-      [] -> [to_charlist(path)]
+      []   -> [to_charlist(path)]
       list -> Enum.map(list, &to_charlist/1)
     end
   end
@@ -295,11 +215,11 @@ defmodule Kernel.CLI do
   end
 
   defp parse_argv(["+elixirc" | t], config) do
-    parse_compiler(t, config)
+    parse_compiler t, config
   end
 
   defp parse_argv(["+iex" | t], config) do
-    parse_iex(t, config)
+    parse_iex t, config
   end
 
   defp parse_argv(["-S", h | t], config) do
@@ -309,10 +229,9 @@ defmodule Kernel.CLI do
   defp parse_argv([h | t] = list, config) do
     case h do
       "-" <> _ ->
-        shared_option?(list, config, &parse_argv(&1, &2))
-
+        shared_option? list, config, &parse_argv(&1, &2)
       _ ->
-        if List.keymember?(config.commands, :eval, 0) do
+        if Keyword.has_key?(config.commands, :eval) do
           {config, list}
         else
           {%{config | commands: [{:file, h} | config.commands]}, t}
@@ -331,46 +250,36 @@ defmodule Kernel.CLI do
   end
 
   defp parse_compiler(["-o", h | t], config) do
-    parse_compiler(t, %{config | output: h})
+    parse_compiler t, %{config | output: h}
   end
 
   defp parse_compiler(["--no-docs" | t], config) do
-    parse_compiler(t, %{config | compiler_options: [{:docs, false} | config.compiler_options]})
+    parse_compiler t, %{config | compiler_options: [{:docs, false} | config.compiler_options]}
   end
 
   defp parse_compiler(["--no-debug-info" | t], config) do
-    compiler_options = [{:debug_info, false} | config.compiler_options]
-    parse_compiler(t, %{config | compiler_options: compiler_options})
+    parse_compiler t, %{config | compiler_options: [{:debug_info, false} | config.compiler_options]}
   end
 
   defp parse_compiler(["--ignore-module-conflict" | t], config) do
-    compiler_options = [{:ignore_module_conflict, true} | config.compiler_options]
-    parse_compiler(t, %{config | compiler_options: compiler_options})
+    parse_compiler t, %{config | compiler_options: [{:ignore_module_conflict, true} | config.compiler_options]}
   end
 
   defp parse_compiler(["--warnings-as-errors" | t], config) do
-    compiler_options = [{:warnings_as_errors, true} | config.compiler_options]
-    parse_compiler(t, %{config | compiler_options: compiler_options})
+    parse_compiler t, %{config | compiler_options: [{:warnings_as_errors, true} | config.compiler_options]}
   end
 
   defp parse_compiler(["--verbose" | t], config) do
-    parse_compiler(t, %{config | verbose_compile: true})
-  end
-
-  # Private compiler options
-
-  defp parse_compiler(["--profile", "time" | t], config) do
-    parse_compiler(t, %{config | profile: :time})
+    parse_compiler t, %{config | verbose_compile: true}
   end
 
   defp parse_compiler([h | t] = list, config) do
     case h do
       "-" <> _ ->
-        shared_option?(list, config, &parse_compiler(&1, &2))
-
+        shared_option? list, config, &parse_compiler(&1, &2)
       _ ->
         pattern = if File.dir?(h), do: "#{h}/**/*.ex", else: h
-        parse_compiler(t, %{config | compile: [pattern | config.compile]})
+        parse_compiler t, %{config | compile: [pattern | config.compile]}
     end
   end
 
@@ -387,11 +296,11 @@ defmodule Kernel.CLI do
   # This clause is here so that Kernel.CLI does not
   # error out with "unknown option"
   defp parse_iex(["--dot-iex", _ | t], config) do
-    parse_iex(t, config)
+    parse_iex t, config
   end
 
   defp parse_iex([opt, _ | t], config) when opt in ["--remsh"] do
-    parse_iex(t, config)
+    parse_iex t, config
   end
 
   defp parse_iex(["-S", h | t], config) do
@@ -400,8 +309,10 @@ defmodule Kernel.CLI do
 
   defp parse_iex([h | t] = list, config) do
     case h do
-      "-" <> _ -> shared_option?(list, config, &parse_iex(&1, &2))
-      _ -> {%{config | commands: [{:file, h} | config.commands]}, t}
+      "-" <> _ ->
+        shared_option? list, config, &parse_iex(&1, &2)
+      _ ->
+        {%{config | commands: [{:file, h} | config.commands]}, t}
     end
   end
 
@@ -412,32 +323,22 @@ defmodule Kernel.CLI do
   # Process commands
 
   defp process_command({:cookie, h}, _config) do
-    if Node.alive?() do
-      wrapper(fn -> Node.set_cookie(String.to_atom(h)) end)
+    if Node.alive? do
+      wrapper fn -> Node.set_cookie(String.to_atom(h)) end
     else
       {:error, "--cookie : Cannot set cookie if the node is not alive (set --name or --sname)"}
     end
   end
 
   defp process_command({:eval, expr}, _config) when is_binary(expr) do
-    wrapper(fn -> Code.eval_string(expr, []) end)
-  end
-
-  defp process_command({:rpc_eval, node, expr}, _config) when is_binary(expr) do
-    case :rpc.call(String.to_atom(node), __MODULE__, :rpc_eval, [expr]) do
-      :ok -> :ok
-      {:badrpc, {:EXIT, exit}} -> Process.exit(self(), exit)
-      {:badrpc, reason} -> {:error, "--rpc-eval : RPC failed with reason #{inspect(reason)}"}
-      {kind, error, stack} -> :erlang.raise(kind, error, stack)
-    end
+    wrapper fn -> Code.eval_string(expr, []) end
   end
 
   defp process_command({:app, app}, _config) when is_binary(app) do
     case Application.ensure_all_started(String.to_atom(app)) do
       {:error, {app, reason}} ->
-        msg = "--app : Could not start application #{app}: " <> Application.format_error(reason)
-        {:error, msg}
-
+        {:error, "--app : Could not start application #{app}: " <>
+          Application.format_error(reason)}
       {:ok, _} ->
         :ok
     end
@@ -445,7 +346,7 @@ defmodule Kernel.CLI do
 
   defp process_command({:script, file}, _config) when is_binary(file) do
     if exec = find_elixir_executable(file) do
-      wrapper(fn -> Code.require_file(exec) end)
+      wrapper fn -> Code.require_file(exec) end
     else
       {:error, "-S : Could not find executable #{file}"}
     end
@@ -453,7 +354,7 @@ defmodule Kernel.CLI do
 
   defp process_command({:file, file}, _config) when is_binary(file) do
     if File.regular?(file) do
-      wrapper(fn -> Code.require_file(file) end)
+      wrapper fn -> Code.require_file(file) end
     else
       {:error, "No file named #{file}"}
     end
@@ -463,7 +364,7 @@ defmodule Kernel.CLI do
     files = filter_patterns(pattern)
 
     if files != [] do
-      wrapper(fn -> Enum.map(files, &Code.require_file(&1)) end)
+      wrapper fn -> Enum.map files, &Code.require_file(&1) end
     else
       {:error, "-r : No files matched pattern #{pattern}"}
     end
@@ -473,12 +374,7 @@ defmodule Kernel.CLI do
     files = filter_patterns(pattern)
 
     if files != [] do
-      wrapper(fn ->
-        case Kernel.ParallelCompiler.require(files) do
-          {:ok, _, _} -> :ok
-          {:error, _, _} -> exit({:shutdown, 1})
-        end
-      end)
+      wrapper fn -> Kernel.ParallelRequire.files(files) end
     else
       {:error, "-pr : No files matched pattern #{pattern}"}
     end
@@ -491,33 +387,17 @@ defmodule Kernel.CLI do
     case filter_multiple_patterns(patterns) do
       {:ok, []} ->
         {:error, "No files matched provided patterns"}
-
       {:ok, files} ->
-        wrapper(fn ->
+        wrapper fn ->
           Code.compiler_options(config.compiler_options)
-
-          verbose_opts =
+          opts =
             if config.verbose_compile do
-              [each_long_compilation: &IO.puts("Compiling #{&1} (it's taking more than 15s)")]
+              [each_long_compilation: &IO.puts("Compiling #{&1} (it's taking more than 5s)")]
             else
               []
             end
-
-          profile_opts =
-            if config.profile do
-              [profile: config.profile]
-            else
-              []
-            end
-
-          opts = verbose_opts ++ profile_opts
-
-          case Kernel.ParallelCompiler.compile_to_path(files, config.output, opts) do
-            {:ok, _, _} -> :ok
-            {:error, _, _} -> exit({:shutdown, 1})
-          end
-        end)
-
+          Kernel.ParallelCompiler.files_to_path(files, config.output, opts)
+        end
       {:missing, missing} ->
         {:error, "No files matched pattern(s) #{Enum.join(missing, ",")}"}
     end
@@ -525,23 +405,31 @@ defmodule Kernel.CLI do
 
   defp filter_patterns(pattern) do
     pattern
-    |> Path.wildcard()
-    |> :lists.usort()
+    |> Path.wildcard
+    |> :lists.usort
     |> Enum.filter(&File.regular?/1)
   end
 
   defp filter_multiple_patterns(patterns) do
-    {files, missing} =
-      Enum.reduce(patterns, {[], []}, fn pattern, {files, missing} ->
-        case filter_patterns(pattern) do
-          [] -> {files, [pattern | missing]}
-          match -> {match ++ files, missing}
-        end
-      end)
+    matched_files = Enum.map patterns, fn(pattern) ->
+      case filter_patterns(pattern) do
+        []    -> {:missing, pattern}
+        files -> {:ok, files}
+      end
+    end
 
-    case missing do
-      [] -> {:ok, :lists.usort(files)}
-      _ -> {:missing, :lists.usort(missing)}
+    files = Enum.filter_map matched_files,
+       fn(match) -> elem(match, 0) == :ok end,
+       &elem(&1, 1)
+
+    missing_patterns = Enum.filter_map matched_files,
+       fn(match) -> elem(match, 0) == :missing end,
+       &elem(&1, 1)
+
+    if missing_patterns == [] do
+      {:ok, :lists.usort(Enum.concat(files))}
+    else
+      {:missing, :lists.usort(missing_patterns)}
     end
   end
 
@@ -559,7 +447,6 @@ defmodule Kernel.CLI do
         {:win32, _} ->
           base = Path.rootname(exec)
           if File.regular?(base), do: base, else: exec
-
         _ ->
           exec
       end

lib/elixir/lib/kernel/error_handler.ex

@@ -5,13 +5,13 @@ defmodule Kernel.ErrorHandler do
 
   @spec undefined_function(module, atom, list) :: term
   def undefined_function(module, fun, args) do
-    ensure_loaded(module) or ensure_compiled(module, :module, :raise)
+    ensure_loaded(module) or ensure_compiled(module, :module)
     :error_handler.undefined_function(module, fun, args)
   end
 
   @spec undefined_lambda(module, fun, list) :: term
   def undefined_lambda(module, fun, args) do
-    ensure_loaded(module) or ensure_compiled(module, :module, :raise)
+    ensure_loaded(module) or ensure_compiled(module, :module)
     :error_handler.undefined_lambda(module, fun, args)
   end
 
@@ -23,21 +23,20 @@ defmodule Kernel.ErrorHandler do
     end
   end
 
-  @spec ensure_compiled(module, atom, atom) :: :found | :not_found | :deadlock
+  @spec ensure_compiled(module, atom) :: boolean
   # Never wait on nil because it should never be defined.
-  def ensure_compiled(nil, _kind, _deadlock) do
-    :not_found
+  def ensure_compiled(nil, _kind) do
+    false
   end
 
-  def ensure_compiled(module, kind, deadlock) do
+  def ensure_compiled(module, kind) do
     parent = :erlang.get(:elixir_compiler_pid)
-    ref = :erlang.make_ref()
-    modules = :elixir_module.compiler_modules()
-    send(parent, {:waiting, kind, self(), ref, module, modules, deadlock})
+    ref    = :erlang.make_ref
+    send parent, {:waiting, kind, self(), ref, module, :elixir_module.compiler_modules()}
     :erlang.garbage_collect(self())
-
     receive do
-      {^ref, value} -> value
+      {^ref, :found}     -> true
+      {^ref, :not_found} -> false
     end
   end
 end

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -6,27 +6,49 @@
 # any of the `GenServer.Behaviour` conveniences.
 defmodule Kernel.LexicalTracker do
   @moduledoc false
-  @timeout :infinity
+  @timeout 30_000
   @behaviour :gen_server
 
   @doc """
-  Returns all references in this lexical scope.
+  Returns all remotes referenced in this lexical scope.
   """
-  def references(pid) do
-    :gen_server.call(pid, :references, @timeout)
+  def remote_references(arg) do
+    :gen_server.call(to_pid(arg), :remote_references, @timeout)
+  end
+
+  @doc """
+  Returns all remote dispatches in this lexical scope.
+  """
+  def remote_dispatches(arg) do
+    :gen_server.call(to_pid(arg), :remote_dispatches, @timeout)
+  end
+
+  @doc """
+  Gets the destination the lexical scope is meant to
+  compile to.
+  """
+  def dest(arg) do
+    :gen_server.call(to_pid(arg), :dest, @timeout)
+  end
+
+  defp to_pid(pid) when is_pid(pid),  do: pid
+  defp to_pid(mod) when is_atom(mod) do
+    table = :elixir_module.data_table(mod)
+    [{_, val}] = :ets.lookup(table, {:elixir, :lexical_tracker})
+    val
   end
 
   # Internal API
 
   # Starts the tracker and returns its PID.
   @doc false
-  def start_link() do
-    :gen_server.start_link(__MODULE__, :ok, [])
+  def start_link(dest) do
+    :gen_server.start_link(__MODULE__, dest, [])
   end
 
   @doc false
   def stop(pid) do
-    :gen_server.call(pid, :stop)
+    :gen_server.cast(pid, :stop)
   end
 
   @doc false
@@ -40,18 +62,18 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def remote_dispatch(pid, module, mode) when is_atom(module) do
-    :gen_server.cast(pid, {:remote_dispatch, module, mode})
+  def remote_reference(pid, module, mode) when is_atom(module) do
+    :gen_server.cast(pid, {:remote_reference, module, mode})
   end
 
   @doc false
-  def remote_struct(pid, module) when is_atom(module) do
-    :gen_server.cast(pid, {:remote_struct, module})
+  def remote_dispatch(pid, module, fa, line, mode) when is_atom(module) do
+    :gen_server.cast(pid, {:remote_dispatch, module, fa, line, mode})
   end
 
   @doc false
-  def import_dispatch(pid, module, fa) when is_atom(module) do
-    :gen_server.cast(pid, {:import_dispatch, module, fa})
+  def import_dispatch(pid, module, fa, line, mode) when is_atom(module) do
+    :gen_server.cast(pid, {:import_dispatch, module, fa, line, mode})
   end
 
   @doc false
@@ -59,33 +81,6 @@ defmodule Kernel.LexicalTracker do
     :gen_server.cast(pid, {:alias_dispatch, module})
   end
 
-  @doc false
-  def add_compile_env(pid, app, path, return) do
-    :gen_server.cast(pid, {:compile_env, app, path, return})
-  end
-
-  @doc false
-  def set_file(pid, file) do
-    :gen_server.cast(pid, {:set_file, file})
-  end
-
-  @doc false
-  def reset_file(pid) do
-    :gen_server.cast(pid, :reset_file)
-  end
-
-  @doc false
-  def write_cache(pid, value) do
-    key = :erlang.unique_integer()
-    :gen_server.cast(pid, {:write_cache, key, value})
-    key
-  end
-
-  @doc false
-  def read_cache(pid, key) do
-    :gen_server.call(pid, {:read_cache, key}, @timeout)
-  end
-
   @doc false
   def collect_unused_imports(pid) do
     unused(pid, :import)
@@ -102,58 +97,49 @@ defmodule Kernel.LexicalTracker do
 
   # Callbacks
 
-  def init(:ok) do
-    state = %{
-      directives: %{},
-      references: %{},
-      structs: %{},
-      cache: %{},
-      compile_env: :ordsets.new(),
-      file: nil
-    }
-
-    {:ok, state}
+  def init(dest) do
+    {:ok, %{directives: %{}, references: %{}, compile: %{},
+            runtime: %{}, dest: dest}}
   end
 
   @doc false
   def handle_call({:unused, tag}, _from, state) do
     directives =
-      for {{^tag, module_or_mfa}, marker} <- state.directives, is_integer(marker) do
-        {module_or_mfa, marker}
-      end
+      for {{^tag, module_or_mfa}, marker} <- state.directives,
+          is_integer(marker),
+          do: {module_or_mfa, marker}
 
     {:reply, Enum.sort(directives), state}
   end
 
-  def handle_call(:references, _from, state) do
-    {compile, runtime} = partition(Map.to_list(state.references), [], [])
-    {:reply, {compile, Map.keys(state.structs), runtime, state.compile_env}, state}
+  def handle_call(:remote_references, _from, state) do
+    {:reply, partition(Enum.to_list(state.references), [], []), state}
   end
 
-  def handle_call({:read_cache, key}, _from, %{cache: cache} = state) do
-    {:reply, Map.get(cache, key), state}
+  def handle_call(:remote_dispatches, _from, state) do
+    {:reply, {state.compile, state.runtime}, state}
   end
 
-  def handle_call(:stop, _from, state) do
-    {:stop, :normal, :ok, state}
+  def handle_call(:dest, _from, state) do
+    {:reply, state.dest, state}
   end
 
-  def handle_cast({:write_cache, key, value}, %{cache: cache} = state) do
-    {:noreply, %{state | cache: Map.put(cache, key, value)}}
+  def handle_cast({:remote_reference, module, mode}, state) do
+    {:noreply, %{state | references: add_reference(state.references, module, mode)}}
   end
 
-  def handle_cast({:remote_struct, module}, state) do
-    structs = Map.put(state.structs, module, true)
-    {:noreply, %{state | structs: structs}}
-  end
-
-  def handle_cast({:remote_dispatch, module, mode}, state) do
+  def handle_cast({:remote_dispatch, module, fa, line, mode}, state) do
     references = add_reference(state.references, module, mode)
+    state = add_remote_dispatch(state, module, fa, line, mode)
     {:noreply, %{state | references: references}}
   end
 
-  def handle_cast({:import_dispatch, module, {function, arity}}, state) do
-    state = add_import_dispatch(state, module, function, arity)
+  def handle_cast({:import_dispatch, module, {function, arity} = fa, line, mode}, state) do
+    state =
+      state
+      |> add_import_dispatch(module, function, arity)
+      |> add_remote_dispatch(module, fa, line, mode)
+
     {:noreply, state}
   end
 
@@ -161,23 +147,11 @@ defmodule Kernel.LexicalTracker do
     {:noreply, %{state | directives: add_dispatch(state.directives, module, :alias)}}
   end
 
-  def handle_cast({:set_file, file}, state) do
-    {:noreply, %{state | file: file}}
-  end
-
-  def handle_cast(:reset_file, state) do
-    {:noreply, %{state | file: nil}}
-  end
-
-  def handle_cast({:compile_env, app, path, return}, state) do
-    {:noreply, update_in(state.compile_env, &:ordsets.add_element({app, path, return}, &1))}
-  end
-
   def handle_cast({:add_import, module, fas, line, warn}, state) do
     directives =
       state.directives
       |> Enum.reject(&match?({{:import, {^module, _, _}}, _}, &1))
-      |> Map.new()
+      |> :maps.from_list
       |> add_directive(module, line, warn, :import)
 
     directives =
@@ -192,6 +166,10 @@ defmodule Kernel.LexicalTracker do
     {:noreply, %{state | directives: add_directive(state.directives, module, line, warn, :alias)}}
   end
 
+  def handle_cast(:stop, state) do
+    {:stop, :normal, state}
+  end
+
   @doc false
   def handle_info(_msg, state) do
     {:noreply, state}
@@ -209,21 +187,23 @@ defmodule Kernel.LexicalTracker do
 
   defp partition([{remote, :compile} | t], compile, runtime),
     do: partition(t, [remote | compile], runtime)
-
   defp partition([{remote, :runtime} | t], compile, runtime),
     do: partition(t, compile, [remote | runtime])
-
-  defp partition([], compile, runtime), do: {compile, runtime}
+  defp partition([], compile, runtime),
+    do: {compile, runtime}
 
   # Callbacks helpers
 
+  defp add_reference(references, module, :runtime) when is_atom(module),
+    do: map_put_new(module, :runtime, references)
   defp add_reference(references, module, :compile) when is_atom(module),
-    do: Map.put(references, module, :compile)
+    do: :maps.put(module, :compile, references)
 
-  defp add_reference(references, module, :runtime) when is_atom(module) do
-    case Map.fetch(references, module) do
-      {:ok, _} -> references
-      :error -> Map.put(references, module, :runtime)
+  defp add_remote_dispatch(state, module, fa, line, mode) when is_atom(module) do
+    map_update mode, %{module => %{fa => [line]}}, state, fn mode_dispatches ->
+      map_update module, %{fa => [line]}, mode_dispatches, fn module_dispatches ->
+        map_update fa, [line], module_dispatches, &[line | List.delete(&1, line)]
+      end
     end
   end
 
@@ -231,10 +211,10 @@ defmodule Kernel.LexicalTracker do
     directives =
       add_dispatch(state.directives, module, :import)
       |> add_dispatch({module, function, arity}, :import)
-
     # Always compile time because we depend
     # on the module at compile time
     references = add_reference(state.references, module, :compile)
+
     %{state | directives: directives, references: references}
   end
 
@@ -243,10 +223,24 @@ defmodule Kernel.LexicalTracker do
   # If the value is true, it was imported/aliased and used
   defp add_directive(directives, module_or_mfa, line, warn, tag) do
     marker = if warn, do: line, else: true
-    Map.put(directives, {tag, module_or_mfa}, marker)
+    :maps.put({tag, module_or_mfa}, marker, directives)
   end
 
   defp add_dispatch(directives, module_or_mfa, tag) do
-    Map.put(directives, {tag, module_or_mfa}, true)
+    :maps.put({tag, module_or_mfa}, true, directives)
+  end
+
+  defp map_update(key, initial, map, fun) do
+    case :maps.find(key, map) do
+      {:ok, val} -> :maps.put(key, fun.(val), map)
+      :error -> :maps.put(key, initial, map)
+    end
+  end
+
+  defp map_put_new(key, value, map) do
+    case :maps.find(key, map) do
+      {:ok, _} -> map
+      :error -> :maps.put(key, value, map)
+    end
   end
 end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -1,41 +1,8 @@
 defmodule Kernel.ParallelCompiler do
   @moduledoc """
-  A module responsible for compiling and requiring files in parallel.
+  A module responsible for compiling files in parallel.
   """
 
-  @doc """
-  Starts a task for parallel compilation.
-
-  If you have a file that needs to compile other modules in parallel,
-  the spawned processes need to be aware of the compiler environment.
-  This function allows a developer to create a task that is aware of
-  those environments.
-
-  See `Task.async/1` for more information. The task spawned must be
-  always awaited on by calling `Task.await/1`
-  """
-  @doc since: "1.6.0"
-  def async(fun) when is_function(fun) do
-    if parent = :erlang.get(:elixir_compiler_pid) do
-      file = :erlang.get(:elixir_compiler_file)
-      dest = :erlang.get(:elixir_compiler_dest)
-      {:error_handler, error_handler} = :erlang.process_info(self(), :error_handler)
-
-      Task.async(fn ->
-        send(parent, {:async, self()})
-        :erlang.put(:elixir_compiler_pid, parent)
-        :erlang.put(:elixir_compiler_file, file)
-        dest != :undefined and :erlang.put(:elixir_compiler_dest, dest)
-        :erlang.process_flag(:error_handler, error_handler)
-        fun.()
-      end)
-    else
-      raise ArgumentError,
-            "cannot spawn parallel compiler task because " <>
-              "the current file is not being compiled/required"
-    end
-  end
-
   @doc """
   Compiles the given files.
 
@@ -44,12 +11,11 @@ defmodule Kernel.ParallelCompiler do
   the current file stops being compiled until the dependency is
   resolved.
 
-  It returns `{:ok, modules, warnings}` or `{:error, errors, warnings}`.
+  If there is an error during compilation or if `warnings_as_errors`
+  is set to `true` and there is a warning, this function will fail
+  with an exception.
 
-  Both errors and warnings are a list of three-element tuples containing
-  the file, line and the formatted error/warning.
-
-  ## Options
+  This function accepts the following options:
 
     * `:each_file` - for each file compiled, invokes the callback passing the
       file
@@ -58,613 +24,324 @@ defmodule Kernel.ParallelCompiler do
       timeout (see the `:long_compilation_threshold` option) to compile, invoke
       this callback passing the file as its argument
 
+    * `:long_compilation_threshold` - the timeout (in seconds) after the
+      `:each_long_compilation` callback is invoked; defaults to `10`
+
     * `:each_module` - for each module compiled, invokes the callback passing
       the file, module and the module bytecode
 
-    * `:each_cycle` - after the given files are compiled, invokes this function
-      that should return the following values:
-      * `{:compile, modules}` - to continue compilation with a list of further modules to compile
-      * `{:runtime, modules}` - to stop compilation and verify the list of modules because
-        dependent modules have changed
-
-    * `:long_compilation_threshold` - the timeout (in seconds) after the
-      `:each_long_compilation` callback is invoked; defaults to `15`
-
-    * `:profile` - if set to `:time` measure the compilation time of each compilation cycle
-       and group pass checker
-
-    * `:dest` - the destination directory for the BEAM files. When using `compile/2`,
+    * `:dest` - the destination directory for the BEAM files. When using `files/2`,
       this information is only used to properly annotate the BEAM files before
       they are loaded into memory. If you want a file to actually be written to
-      `dest`, use `compile_to_path/3` instead.
-
-    * `:beam_timestamp` - the modification timestamp to give all BEAM files
+      `dest`, use `files_to_path/3` instead.
 
+  Returns the modules generated by each compiled file.
   """
-  @doc since: "1.6.0"
-  def compile(files, options \\ []) when is_list(options) do
-    spawn_workers(files, :compile, options)
-  end
+  def files(files, options \\ [])
 
-  @doc since: "1.6.0"
-  def compile_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
-    spawn_workers(files, {:compile, path}, options)
+  def files(files, options) when is_list(options) do
+    spawn_compilers(files, nil, options)
   end
 
   @doc """
-  Requires the given files in parallel.
-
-  Opposite to compile, dependencies are not attempted to be
-  automatically solved between files.
-
-  It returns `{:ok, modules, warnings}` or `{:error, errors, warnings}`.
-
-  Both errors and warnings are a list of three-element tuples containing
-  the file, line and the formatted error/warning.
-
-  ## Options
-
-    * `:each_file` - for each file compiled, invokes the callback passing the
-      file
-
-    * `:each_module` - for each module compiled, invokes the callback passing
-      the file, module and the module bytecode
-
+  Compiles the given files to the given path.
+  Read `files/2` for more information.
   """
-  @doc since: "1.6.0"
-  def require(files, options \\ []) when is_list(options) do
-    spawn_workers(files, :require, options)
+  def files_to_path(files, path, options \\ [])
+
+  def files_to_path(files, path, options) when is_binary(path) and is_list(options) do
+    spawn_compilers(files, path, options)
   end
 
-  @doc false
-  @deprecated "Use Kernel.ParallelCompiler.compile/2 instead"
-  def files(files, options \\ []) when is_list(options) do
-    case spawn_workers(files, :compile, options) do
-      {:ok, modules, _} -> modules
-      {:error, _, _} -> exit({:shutdown, 1})
-    end
-  end
-
-  @doc false
-  @deprecated "Use Kernel.ParallelCompiler.compile_to_path/2 instead"
-  def files_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
-    case spawn_workers(files, {:compile, path}, options) do
-      {:ok, modules, _} -> modules
-      {:error, _, _} -> exit({:shutdown, 1})
-    end
-  end
-
-  defp spawn_workers(files, output, options) do
-    {:module, _} = :code.ensure_loaded(Kernel.ErrorHandler)
+  defp spawn_compilers(files, path, options) do
+    true = Code.ensure_loaded?(Kernel.ErrorHandler)
     compiler_pid = self()
     :elixir_code_server.cast({:reset_warnings, compiler_pid})
     schedulers = max(:erlang.system_info(:schedulers_online), 2)
-    beam_timestamp = Keyword.get(options, :beam_timestamp)
 
-    outcome =
-      spawn_workers(files, 0, [], [], %{}, [], %{
-        dest: Keyword.get(options, :dest),
-        each_cycle: Keyword.get(options, :each_cycle, fn -> {:runtime, []} end),
-        each_file: Keyword.get(options, :each_file, fn _, _ -> :ok end) |> each_file(),
-        each_long_compilation: Keyword.get(options, :each_long_compilation, fn _file -> :ok end),
-        each_module: Keyword.get(options, :each_module, fn _file, _module, _binary -> :ok end),
-        long_compilation_threshold: Keyword.get(options, :long_compilation_threshold, 15),
-        profile: Keyword.get(options, :profile),
-        cycle_start: System.monotonic_time(),
-        module_counter: 0,
-        output: output,
-        schedulers: schedulers
-      })
+    result = spawn_compilers(%{
+      entries: files,
+      original: files,
+      output: path,
+      options: options,
+      waiting: [],
+      queued: [],
+      schedulers: schedulers,
+      result: [],
+    })
 
     # In case --warning-as-errors is enabled and there was a warning,
     # compilation status will be set to error.
-    compilation_status = :elixir_code_server.call({:compilation_status, compiler_pid})
-
-    case {outcome, compilation_status} do
-      {{:ok, _, warnings}, :error} ->
-        message = "Compilation failed due to warnings while using the --warnings-as-errors option"
-        IO.puts(:stderr, message)
-        {:error, warnings, []}
-
-      {{:error, errors, warnings}, :error} ->
-        {:error, errors ++ warnings, []}
-
-      {{:ok, outcome, warnings}, _} ->
-        {:ok, write_module_binaries(outcome, output, beam_timestamp), warnings}
-
-      {{:error, errors, warnings}, _} ->
-        {:error, errors, warnings}
+    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
+      :ok ->
+        result
+      :error ->
+        IO.puts :stderr, "Compilation failed due to warnings while using the --warnings-as-errors option"
+        exit({:shutdown, 1})
     end
   end
 
-  defp each_file(fun) when is_function(fun, 1), do: fn file, _ -> fun.(file) end
-  defp each_file(fun) when is_function(fun, 2), do: fun
-
-  defp each_file(file, lexical, parent) do
-    ref = Process.monitor(parent)
-    send(parent, {:file_ok, self(), ref, file, lexical})
-
-    receive do
-      ^ref -> :ok
-      {:DOWN, ^ref, _, _, _} -> :ok
-    end
-  end
-
-  defp write_module_binaries(result, {:compile, path}, timestamp) do
-    Enum.flat_map(result, fn
-      {{:module, module}, {binary, _map}} ->
-        full_path = Path.join(path, Atom.to_string(module) <> ".beam")
-        File.write!(full_path, binary)
-        if timestamp, do: File.touch!(full_path, timestamp)
-        [module]
-
-      _ ->
-        []
-    end)
-  end
-
-  defp write_module_binaries(result, _output, _timestamp) do
-    for {{:module, module}, _} <- result, do: module
-  end
-
-  ## Verification
-
-  defp verify_modules(result, warnings, dependent_modules, state) do
-    checker_warnings = maybe_check_modules(result, dependent_modules, state)
-    warnings = Enum.reverse(warnings, checker_warnings)
-    {:ok, result, warnings}
-  end
-
-  defp maybe_check_modules(result, runtime_modules, state) do
-    %{schedulers: schedulers, profile: profile} = state
-
-    if :elixir_config.get(:bootstrap) do
-      []
-    else
-      compiled_modules = checker_compiled_modules(result)
-      runtime_modules = checker_runtime_modules(runtime_modules)
-
-      profile_checker(profile, compiled_modules, runtime_modules, fn ->
-        Module.ParallelChecker.verify(compiled_modules, runtime_modules, schedulers)
-      end)
-    end
-  end
-
-  defp checker_compiled_modules(result) do
-    for {{:module, _module}, {binary, module_map}} <- result do
-      {module_map, binary}
-    end
-  end
-
-  defp checker_runtime_modules(modules) do
-    for module <- modules,
-        path = :code.which(module),
-        is_list(path) and path != [] do
-      {module, File.read!(path)}
-    end
-  end
-
-  defp profile_checker(_profile = :time, compiled_modules, runtime_modules, fun) do
-    {time, result} = :timer.tc(fun)
-    time = div(time, 1000)
-    num_modules = length(compiled_modules) + length(runtime_modules)
-    IO.puts(:stderr, "[profile] Finished group pass check of #{num_modules} modules in #{time}ms")
-    result
-  end
-
-  defp profile_checker(_profile = nil, _compiled_modules, _runtime_modules, fun) do
-    fun.()
-  end
-
-  ## Compiler worker spawning
-
   # We already have n=schedulers currently running, don't spawn new ones
-  defp spawn_workers(
-         queue,
-         spawned,
-         waiting,
-         files,
-         result,
-         warnings,
-         %{schedulers: schedulers} = state
-       )
-       when spawned - length(waiting) >= schedulers do
-    wait_for_messages(queue, spawned, waiting, files, result, warnings, state)
+  defp spawn_compilers(%{queued: queued, waiting: waiting, schedulers: schedulers} = state)
+      when length(queued) - length(waiting) >= schedulers do
+    wait_for_messages(state)
   end
 
   # Release waiting processes
-  defp spawn_workers([{ref, found} | t], spawned, waiting, files, result, warnings, state) do
+  defp spawn_compilers(%{entries: [{ref, found} | t], waiting: waiting} = state) do
     waiting =
       case List.keytake(waiting, ref, 2) do
-        {{_kind, pid, ^ref, _on, _defining, _deadlock}, waiting} ->
-          send(pid, {ref, found})
+        {{_kind, pid, ^ref, _on, _defining}, waiting} ->
+          send pid, {ref, found}
           waiting
-
         nil ->
-          # In case the waiting process died (for example, it was an async process),
-          # it will no longer be on the list. So we need to take it into account here.
           waiting
       end
-
-    spawn_workers(t, spawned, waiting, files, result, warnings, state)
+    spawn_compilers(%{state | entries: t, waiting: waiting})
   end
 
-  defp spawn_workers([file | queue], spawned, waiting, files, result, warnings, state) do
-    %{output: output, long_compilation_threshold: threshold, dest: dest} = state
+  defp spawn_compilers(%{entries: [file | files], queued: queued, output: output, options: options} = state) do
     parent = self()
-    file = Path.expand(file)
 
     {pid, ref} =
-      :erlang.spawn_monitor(fn ->
+      :erlang.spawn_monitor fn ->
+        # Set the elixir_compiler_pid used by our custom Kernel.ErrorHandler.
         :erlang.put(:elixir_compiler_pid, parent)
         :erlang.put(:elixir_compiler_file, file)
+        :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
 
-        try do
-          case output do
-            {:compile, path} -> compile_file(file, path, parent)
-            :compile -> compile_file(file, dest, parent)
-            :require -> require_file(file, parent)
+        exit(try do
+          _ = if output do
+            :elixir_compiler.file_to_path(file, output)
+          else
+            :elixir_compiler.file(file, Keyword.get(options, :dest))
           end
+          {:shutdown, file}
         catch
           kind, reason ->
-            send(parent, {:file_error, self(), file, {kind, reason, __STACKTRACE__}})
-        end
+            {:failure, kind, reason, System.stacktrace}
+        end)
+      end
 
-        exit(:shutdown)
-      end)
+    timeout = Keyword.get(options, :long_compilation_threshold, 10) * 1_000
+    timer_ref = Process.send_after(self(), {:timed_out, pid}, timeout)
 
-    timer_ref = Process.send_after(self(), {:timed_out, pid}, threshold * 1000)
-    files = [{pid, ref, file, timer_ref} | files]
-    spawn_workers(queue, spawned + 1, waiting, files, result, warnings, state)
+    new_queued = [{pid, ref, file, timer_ref} | queued]
+    spawn_compilers(%{state | entries: files, queued: new_queued})
   end
 
-  # No more queue, nothing waiting, this cycle is done
-  defp spawn_workers([], 0, [], [], result, warnings, state) do
-    state = cycle_timing(result, state)
+  # No more files, nothing waiting, queue is empty, we are done
+  defp spawn_compilers(%{entries: [], waiting: [], queued: [], result: result}) do
+    for {:module, mod} <- result, do: mod
+  end
 
-    case each_cycle_return(state.each_cycle.()) do
-      {:runtime, dependent_modules} ->
-        verify_modules(result, warnings, dependent_modules, state)
+  # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
+  defp spawn_compilers(%{entries: [], waiting: waiting, queued: queued} = state) when length(waiting) == length(queued) do
+    entries = for {pid, _, _, _} <- queued,
+                  entry = waiting_on_without_definition(waiting, pid),
+                  {_, _, ref, on, _} = entry,
+                  do: {on, {ref, :not_found}}
 
-      {:compile, []} ->
-        verify_modules(result, warnings, [], state)
+    # Instead of releasing all files at once, we release them in groups
+    # based on the module they are waiting on. We pick the module being
+    # depended on with less edges, as it is the mostly likely source of
+    # error (for example, someone made a typo). This may not always be
+    # true though: for example, if there is a macro injecting code into
+    # multiple modules and such code becomes faulty, now multiple modules
+    # are waiting on the same module required by the faulty code. However,
+    # since we need to pick something to be first, the one with fewer edges
+    # sounds like a sane choice.
+    entries =
+      entries
+      |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
+      |> Enum.sort_by(&length(elem(&1, 1)))
+      |> Enum.find_value([], &elem(&1, 1))
 
-      {:compile, more} ->
-        spawn_workers(more, 0, [], [], result, warnings, state)
+    case entries do
+      [] -> handle_deadlock(waiting, queued)
+      _  -> spawn_compilers(%{state | entries: entries})
     end
   end
 
-  # files x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-
-  # Single entry, just release it.
-  defp spawn_workers(
-         [],
-         1,
-         [{_, pid, ref, _, _, _}] = waiting,
-         [{pid, _, _, _}] = files,
-         result,
-         warnings,
-         state
-       ) do
-    spawn_workers([{ref, :not_found}], 1, waiting, files, result, warnings, state)
+  # No more files, but queue and waiting are not full or do not match
+  defp spawn_compilers(%{entries: []} = state) do
+    wait_for_messages(state)
   end
 
-  # Multiple entries, try to release modules.
-  defp spawn_workers([], spawned, waiting, files, result, warnings, state)
-       when length(waiting) == spawned do
-    # There is potentially a deadlock. We will release modules with
-    # the following order:
-    #
-    #   1. Code.ensure_compiled/1 checks (deadlock = soft)
-    #   2. Struct checks (deadlock = hard)
-    #   3. Modules without a known definition
-    #   4. Code invocation (deadlock = raise)
-    #
-    # In theory there is no difference between hard and raise, the
-    # difference is where the raise is happening, inside the compiler
-    # or in the caller.
-    cond do
-      deadlocked = deadlocked(waiting, :soft) || deadlocked(waiting, :hard) ->
-        spawn_workers(deadlocked, spawned, waiting, files, result, warnings, state)
-
-      without_definition = without_definition(waiting, files) ->
-        spawn_workers(without_definition, spawned, waiting, files, result, warnings, state)
-
-      true ->
-        errors = handle_deadlock(waiting, files)
-        {:error, errors, warnings}
+  defp waiting_on_without_definition(waiting, pid) do
+    {_, ^pid, _, on, _} = entry = List.keyfind(waiting, pid, 1)
+    if Enum.any?(waiting, fn {_, _, _, _, defining} -> on in defining end) do
+      nil
+    else
+      entry
     end
   end
 
-  # No more queue, but spawned and length(waiting) do not match
-  defp spawn_workers([], spawned, waiting, files, result, warnings, state) do
-    wait_for_messages([], spawned, waiting, files, result, warnings, state)
-  end
-
-  defp compile_file(file, path, parent) do
-    :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-    :erlang.put(:elixir_compiler_dest, path)
-    :elixir_compiler.file(file, &each_file(&1, &2, parent))
-  end
-
-  defp require_file(file, parent) do
-    case :elixir_code_server.call({:acquire, file}) do
-      :required ->
-        send(parent, {:file_cancel, self()})
-
-      :proceed ->
-        :elixir_compiler.file(file, &each_file(&1, &2, parent))
-        :elixir_code_server.cast({:required, file})
-    end
-  end
-
-  defp cycle_timing(result, %{profile: :time} = state) do
-    %{cycle_start: cycle_start, module_counter: module_counter} = state
-    num_modules = count_modules(result)
-    diff_modules = num_modules - module_counter
-    now = System.monotonic_time()
-    time = System.convert_time_unit(now - cycle_start, :native, :millisecond)
-
-    IO.puts(
-      :stderr,
-      "[profile] Finished compilation cycle of #{diff_modules} modules in #{time}ms"
-    )
-
-    %{state | cycle_start: now, module_counter: num_modules}
-  end
-
-  defp cycle_timing(_result, %{profile: nil} = state) do
-    state
-  end
-
-  defp count_modules(result) do
-    Enum.count(result, &match?({{:module, _}, _}, &1))
-  end
-
-  # TODO: Deprecate on v1.14
-  defp each_cycle_return(modules) when is_list(modules), do: {:compile, modules}
-  defp each_cycle_return(other), do: other
-
-  # The goal of this function is to find leaves in the dependency graph,
-  # i.e. to find code that depends on code that we know is not being defined.
-  # Note that not all files have been compile yet, so they may not be in waiting.
-  defp without_definition(waiting, files) do
-    nillify_empty(
-      for {pid, _, _, _} <- files,
-          {_, ^pid, ref, on, _, _} <- List.wrap(List.keyfind(waiting, pid, 1)),
-          not Enum.any?(waiting, fn {_, _, _, _, defining, _} -> on in defining end),
-          do: {ref, :not_found}
-    )
-  end
-
-  defp deadlocked(waiting, type) do
-    nillify_empty(for {_, _, ref, _, _, ^type} <- waiting, do: {ref, :deadlock})
-  end
-
-  defp nillify_empty([]), do: nil
-  defp nillify_empty([_ | _] = list), do: list
-
   # Wait for messages from child processes
-  defp wait_for_messages(queue, spawned, waiting, files, result, warnings, state) do
-    %{output: output} = state
+  defp wait_for_messages(state) do
+    %{entries: entries, options: options, waiting: waiting, queued: queued, result: result} = state
 
     receive do
-      {:async, process} ->
-        Process.monitor(process)
-        wait_for_messages(queue, spawned + 1, waiting, files, result, warnings, state)
+      {:struct_available, module} ->
+        available = for {:struct, _, ref, waiting_module, _defining} <- waiting,
+                        module == waiting_module,
+                        do: {ref, :found}
 
-      {:available, kind, module} ->
-        available =
-          for {^kind, _, ref, ^module, _defining, _deadlock} <- waiting,
-              do: {ref, :found}
+        spawn_compilers(%{state | entries: available ++ entries, result: [{:struct, module} | result]})
 
-        result = Map.put(result, {kind, module}, true)
-        spawn_workers(available ++ queue, spawned, waiting, files, result, warnings, state)
-
-      {:module_available, child, ref, file, module, binary, module_map} ->
-        state.each_module.(file, module, binary)
+      {:module_available, child, ref, file, module, binary} ->
+        if callback = Keyword.get(options, :each_module) do
+          callback.(file, module, binary)
+        end
 
         # Release the module loader which is waiting for an ack
-        send(child, {ref, :ack})
+        send child, {ref, :ack}
 
-        available =
-          for {:module, _, ref, ^module, _defining, _deadlock} <- waiting,
-              do: {ref, :found}
+        available = for {:module, _, ref, waiting_module, _defining} <- waiting,
+                        module == waiting_module,
+                        do: {ref, :found}
 
-        cancel_waiting_timer(files, child)
-        result = Map.put(result, {:module, module}, {binary, module_map})
-        spawn_workers(available ++ queue, spawned, waiting, files, result, warnings, state)
+        cancel_waiting_timer(queued, child)
 
-      # If we are simply requiring files, we do not add to waiting.
-      {:waiting, _kind, child, ref, _on, _defining, _deadlock} when output == :require ->
-        send(child, {ref, :not_found})
-        spawn_workers(queue, spawned, waiting, files, result, warnings, state)
+        spawn_compilers(%{state | entries: available ++ entries, result: [{:module, module} | result]})
 
-      {:waiting, kind, child, ref, on, defining, deadlock?} ->
-        # If we already got what we were waiting for, do not put it on waiting.
+      {:waiting, kind, child, ref, on, defining} ->
+        # Oops, we already got it, do not put it on waiting.
         # Alternatively, we're waiting on ourselves,
         # send :found so that we can crash with a better error.
         waiting =
-          if Map.has_key?(result, {kind, on}) or on in defining do
-            send(child, {ref, :found})
+          if :lists.any(&match?({^kind, ^on}, &1), result) or on in defining do
+            send child, {ref, :found}
             waiting
           else
-            [{kind, child, ref, on, defining, deadlock?} | waiting]
+            [{kind, child, ref, on, defining} | waiting]
           end
 
-        spawn_workers(queue, spawned, waiting, files, result, warnings, state)
+        spawn_compilers(%{state | waiting: waiting})
 
       {:timed_out, child} ->
-        case List.keyfind(files, child, 0) do
-          {^child, _, file, _} -> state.each_long_compilation.(file)
-          _ -> :ok
+        callback = Keyword.get(options, :each_long_compilation)
+        case List.keyfind(queued, child, 0) do
+          {^child, _, file, _} when not is_nil(callback) ->
+            callback.(file)
+          _ ->
+            :ok
+        end
+        spawn_compilers(state)
+
+      {:DOWN, _down_ref, :process, down_pid, {:shutdown, file}} ->
+        if callback = Keyword.get(options, :each_file) do
+          callback.(file)
         end
 
-        spawn_workers(queue, spawned, waiting, files, result, warnings, state)
+        cancel_waiting_timer(queued, down_pid)
 
-      {:warning, file, line, message} ->
-        file = file && Path.absname(file)
-        message = :unicode.characters_to_binary(message)
-        warning = {file, line, message}
-        wait_for_messages(queue, spawned, waiting, files, result, [warning | warnings], state)
+        # Sometimes we may have spurious entries in the waiting
+        # list because someone invoked try/rescue UndefinedFunctionError
+        new_entries = List.delete(entries, down_pid)
+        new_queued  = List.keydelete(queued, down_pid, 0)
+        new_waiting = List.keydelete(waiting, down_pid, 1)
+        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
 
-      {:file_ok, child_pid, ref, file, lexical} ->
-        state.each_file.(file, lexical)
-        send(child_pid, ref)
-        cancel_waiting_timer(files, child_pid)
-
-        discard_down(child_pid)
-        new_files = List.keydelete(files, child_pid, 0)
-
-        # Sometimes we may have spurious entries in the waiting list
-        # because someone invoked try/rescue UndefinedFunctionError
-        new_waiting = List.keydelete(waiting, child_pid, 1)
-        spawn_workers(queue, spawned - 1, new_waiting, new_files, result, warnings, state)
-
-      {:file_cancel, child_pid} ->
-        cancel_waiting_timer(files, child_pid)
-        discard_down(child_pid)
-        new_files = List.keydelete(files, child_pid, 0)
-        spawn_workers(queue, spawned - 1, waiting, new_files, result, warnings, state)
-
-      {:file_error, child_pid, file, {kind, reason, stack}} ->
-        print_error(file, kind, reason, stack)
-        cancel_waiting_timer(files, child_pid)
-        discard_down(child_pid)
-        files |> List.keydelete(child_pid, 0) |> terminate()
-        {:error, [to_error(file, kind, reason, stack)], warnings}
-
-      {:DOWN, ref, :process, pid, reason} ->
-        waiting = List.keydelete(waiting, pid, 1)
-
-        case handle_down(files, ref, reason) do
-          :ok -> wait_for_messages(queue, spawned - 1, waiting, files, result, warnings, state)
-          {:error, errors} -> {:error, errors, warnings}
-        end
+      {:DOWN, down_ref, :process, _down_pid, reason} ->
+        handle_failure(down_ref, reason, queued)
+        wait_for_messages(state)
     end
   end
 
-  defp discard_down(pid) do
-    receive do
-      {:DOWN, _, :process, ^pid, _} -> :ok
-    end
-  end
-
-  defp handle_down(_files, _ref, :normal) do
-    :ok
-  end
-
-  defp handle_down(files, ref, reason) do
-    case List.keyfind(files, ref, 1) do
-      {child_pid, ^ref, file, _timer_ref} ->
-        print_error(file, :exit, reason, [])
-
-        files
-        |> List.keydelete(child_pid, 0)
-        |> terminate()
-
-        {:error, [to_error(file, :exit, reason, [])]}
-
-      _ ->
-        :ok
-    end
-  end
-
-  defp handle_deadlock(waiting, files) do
+  defp handle_deadlock(waiting, queued) do
     deadlock =
-      for {pid, _, file, _} <- files do
+      for {pid, _, file, _} <- queued do
         {:current_stacktrace, stacktrace} = Process.info(pid, :current_stacktrace)
         Process.exit(pid, :kill)
 
-        {kind, ^pid, _, on, _, _} = List.keyfind(waiting, pid, 1)
-        description = "deadlocked waiting on #{kind} #{inspect(on)}"
-        error = CompileError.exception(description: description, file: nil, line: nil)
-        print_error(file, :error, error, stacktrace)
-        {Path.relative_to_cwd(file), on, description}
+        {_kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
+        error = CompileError.exception(description: "deadlocked waiting on module #{inspect on}",
+                                       file: nil, line: nil)
+        print_failure(file, {:failure, :error, error, stacktrace})
+
+        {file, on}
       end
 
-    IO.puts("""
+    IO.puts """
 
     Compilation failed because of a deadlock between files.
     The following files depended on the following modules:
-    """)
+    """
 
     max =
       deadlock
-      |> Enum.map(&(&1 |> elem(0) |> String.length()))
-      |> Enum.max()
+      |> Enum.map(& &1 |> elem(0) |> String.length)
+      |> Enum.max
 
-    for {file, mod, _} <- deadlock do
-      IO.puts(["  ", String.pad_leading(file, max), " => " | inspect(mod)])
+    for {file, mod} <- deadlock do
+      IO.puts ["  ", String.pad_leading(file, max), " => " | inspect(mod)]
     end
 
-    IO.puts(
-      "\nEnsure there are no compile-time dependencies between those files " <>
-        "and that the modules they reference exist and are correctly named\n"
-    )
-
-    for {file, _, description} <- deadlock, do: {Path.absname(file), nil, description}
+    IO.puts ""
+    exit({:shutdown, 1})
   end
 
-  defp terminate(files) do
-    for {pid, _, _, _} <- files, do: Process.exit(pid, :kill)
-    for {pid, _, _, _} <- files, do: discard_down(pid)
+  defp handle_failure(ref, reason, queued) do
+    if file = find_failure(ref, queued) do
+      print_failure(file, reason)
+      for {pid, _, _, _} <- queued do
+        Process.exit(pid, :kill)
+      end
+      exit({:shutdown, 1})
+    end
+  end
+
+  defp find_failure(ref, queued) do
+    case List.keyfind(queued, ref, 1) do
+      {_child, ^ref, file, _timer_ref} -> file
+      _ -> nil
+    end
+  end
+
+  defp print_failure(_file, {:shutdown, _}) do
     :ok
   end
 
-  defp print_error(file, kind, reason, stack) do
-    IO.write([
-      "\n== Compilation error in file #{Path.relative_to_cwd(file)} ==\n",
-      Kernel.CLI.format_error(kind, reason, stack)
-    ])
+  defp print_failure(file, {:failure, kind, reason, stacktrace}) do
+    IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
+    IO.puts Exception.format(kind, reason, prune_stacktrace(stacktrace))
   end
 
-  defp cancel_waiting_timer(files, child_pid) do
-    case List.keyfind(files, child_pid, 0) do
+  defp print_failure(file, reason) do
+    IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
+    IO.puts Exception.format(:exit, reason, [])
+  end
+
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
+                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
+                     :elixir_def, :elixir_map, Kernel.ErrorHandler]
+
+  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
+    prune_stacktrace(t)
+  end
+
+  defp prune_stacktrace([h | t]) do
+    [h | prune_stacktrace(t)]
+  end
+
+  defp prune_stacktrace([]) do
+    []
+  end
+
+  defp cancel_waiting_timer(queued, child_pid) do
+    case List.keyfind(queued, child_pid, 0) do
       {^child_pid, _ref, _file, timer_ref} ->
         Process.cancel_timer(timer_ref)
-        # Let's flush the message in case it arrived before we canceled the timeout.
+        # Let's flush the message in case it arrived before we canceled the
+        # timeout.
         receive do
           {:timed_out, ^child_pid} -> :ok
         after
           0 -> :ok
         end
-
       nil ->
         :ok
     end
   end
-
-  defp to_error(file, kind, reason, stack) do
-    line = get_line(file, reason, stack)
-    file = Path.absname(file)
-    message = :unicode.characters_to_binary(Kernel.CLI.format_error(kind, reason, stack))
-    {file, line, message}
-  end
-
-  defp get_line(_file, %{line: line}, _stack) when is_integer(line) and line > 0 do
-    line
-  end
-
-  defp get_line(file, :undef, [{_, _, _, []}, {_, _, _, info} | _]) do
-    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
-      Keyword.get(info, :line)
-    end
-  end
-
-  defp get_line(file, _reason, [{_, _, _, [file: 'expanding macro']}, {_, _, _, info} | _]) do
-    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
-      Keyword.get(info, :line)
-    end
-  end
-
-  defp get_line(file, _reason, [{_, _, _, info} | _]) do
-    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
-      Keyword.get(info, :line)
-    end
-  end
-
-  defp get_line(_, _, _) do
-    nil
-  end
 end

lib/elixir/lib/kernel/parallel_require.ex

@@ -1,17 +1,109 @@
 defmodule Kernel.ParallelRequire do
-  @moduledoc false
+  @moduledoc """
+  A module responsible for requiring files in parallel.
+  """
 
-  @deprecated "Use Kernel.ParallelCompiler.require/2 instead"
+  @doc """
+  Requires the given files.
+
+  A callback that will be invoked with each file, or a keyword list of `callbacks` can be provided:
+
+    * `:each_file` - invoked with each file
+
+    * `:each_module` - invoked with file, module name, and binary code
+
+  Returns the modules generated by each required file.
+  """
   def files(files, callbacks \\ [])
 
   def files(files, callback) when is_function(callback, 1) do
-    files(files, each_file: callback)
+    files(files, [each_file: callback])
   end
 
-  def files(files, options) when is_list(options) do
-    case Kernel.ParallelCompiler.require(files, options) do
-      {:ok, modules, _} -> modules
-      {:error, _, _} -> exit({:shutdown, 1})
+  def files(files, callbacks) when is_list(callbacks) do
+    compiler_pid = self()
+    :elixir_code_server.cast({:reset_warnings, compiler_pid})
+    schedulers = max(:erlang.system_info(:schedulers_online), 2)
+    result = spawn_requires(files, [], callbacks, schedulers, [])
+
+    # In case --warning-as-errors is enabled and there was a warning,
+    # compilation status will be set to error.
+    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
+      :ok ->
+        result
+      :error ->
+        IO.puts :stderr, "\nExecution failed due to warnings while using the --warnings-as-errors option"
+        exit({:shutdown, 1})
+    end
+  end
+
+  defp spawn_requires([], [], _callbacks, _schedulers, result), do: result
+
+  defp spawn_requires([], waiting, callbacks, schedulers, result) do
+    wait_for_messages([], waiting, callbacks, schedulers, result)
+  end
+
+  defp spawn_requires(files, waiting, callbacks, schedulers, result) when length(waiting) >= schedulers do
+    wait_for_messages(files, waiting, callbacks, schedulers, result)
+  end
+
+  defp spawn_requires([file | files], waiting, callbacks, schedulers, result) do
+    parent = self()
+    {pid, ref} = :erlang.spawn_monitor fn ->
+      :erlang.put(:elixir_compiler_pid, parent)
+      :erlang.put(:elixir_compiler_file, file)
+
+      exit(try do
+        new = Code.require_file(file) || []
+        {:required, Enum.map(new, &elem(&1, 0)), file}
+      catch
+        kind, reason ->
+          {:failure, kind, reason, System.stacktrace}
+      end)
+    end
+
+    spawn_requires(files, [{pid, ref} | waiting], callbacks, schedulers, result)
+  end
+
+  defp wait_for_messages(files, waiting, callbacks, schedulers, result) do
+    receive do
+      {:DOWN, ref, :process, pid, status} ->
+        tuple = {pid, ref}
+        if tuple in waiting do
+          waiting = List.delete(waiting, tuple)
+
+          case status do
+            {:required, mods, file} ->
+              if each_file_callback = callbacks[:each_file] do
+                each_file_callback.(file)
+              end
+
+              spawn_requires(files, waiting, callbacks, schedulers, mods ++ result)
+
+            {:failure, kind, reason, stacktrace} ->
+              :erlang.raise(kind, reason, stacktrace)
+
+            other ->
+              :erlang.raise(:exit, other, [])
+          end
+        else
+          spawn_requires(files, waiting, callbacks, schedulers, result)
+        end
+
+      {:module_available, child, ref, file, module, binary} ->
+        if each_module_callback = callbacks[:each_module] do
+          each_module_callback.(file, module, binary)
+        end
+
+        send(child, {ref, :ack})
+        spawn_requires(files, waiting, callbacks, schedulers, result)
+
+      {:struct_available, _} ->
+        spawn_requires(files, waiting, callbacks, schedulers, result)
+
+      {:waiting, _, child, ref, _, _} ->
+        send(child, {ref, :not_found})
+        spawn_requires(files, waiting, callbacks, schedulers, result)
     end
   end
 end

lib/elixir/lib/kernel/utils.ex

@@ -6,13 +6,10 @@ defmodule Kernel.Utils do
   @doc """
   Callback for destructure.
   """
-  def destructure(list, count)
-      when is_list(list) and is_integer(count) and count >= 0,
-      do: destructure_list(list, count)
-
-  def destructure(nil, count)
-      when is_integer(count) and count >= 0,
-      do: destructure_nil(count)
+  def destructure(list, count) when is_list(list) and is_integer(count) and count >= 0,
+    do: destructure_list(list, count)
+  def destructure(nil, count) when is_integer(count) and count >= 0,
+    do: destructure_nil(count)
 
   defp destructure_list(_, 0), do: []
   defp destructure_list([], count), do: destructure_nil(count)
@@ -25,8 +22,8 @@ defmodule Kernel.Utils do
   Callback for defdelegate.
   """
   def defdelegate(fun, opts) when is_list(opts) do
-    # TODO: Remove on v2.0
-    append_first? = Keyword.get(opts, :append_first, false)
+    # TODO: Remove by 2.0
+    append_first = Keyword.get(opts, :append_first, false)
 
     {name, args} =
       case Macro.decompose_call(fun) do
@@ -34,31 +31,38 @@ defmodule Kernel.Utils do
         _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
       end
 
+    as_args_list = normalize_args(args)
     as = Keyword.get(opts, :as, name)
-    as_args = build_as_args(args, append_first?)
-
-    {name, args, as, as_args}
+    :lists.map(fn as_args ->
+      formal_args = make_formal_args(as_args)
+      as_args = case append_first do
+        true  -> tl(as_args) ++ [hd(as_args)]
+        false -> as_args
+      end
+      {name, formal_args, as, as_args}
+    end, as_args_list)
   end
 
-  defp build_as_args(args, append_first?) do
-    as_args = :lists.map(&build_as_arg/1, args)
-
-    case append_first? do
-      true -> tl(as_args) ++ [hd(as_args)]
-      false -> as_args
-    end
+  defp make_formal_args(args) do
+    fun = &match?({name, _, mod} when is_atom(name) and is_atom(mod), &1)
+    :lists.filter(fun, args)
   end
 
-  defp build_as_arg({:\\, _, [arg, _default_arg]}), do: validate_arg(arg)
-  defp build_as_arg(arg), do: validate_arg(arg)
-
-  defp validate_arg({name, _, mod} = arg) when is_atom(name) and is_atom(mod) do
-    arg
+  defp normalize_args(raw_args) do
+    :lists.foldr(fn
+      ({:\\, _, [arg, default_arg]}, [as_args | _] = as_args_list) ->
+        new_as_args = [default_arg | as_args]
+        [new_as_args | add_arg(as_args_list, arg)]
+      (arg, as_args_list) ->
+        add_arg(as_args_list, arg)
+    end, [[]], raw_args)
   end
 
-  defp validate_arg(ast) do
+  defp add_arg(as_args_list, {name, _, mod} = arg) when is_atom(name) and is_atom(mod),
+    do: :lists.map(&([arg | &1]), as_args_list)
+  defp add_arg(_, code) do
     raise ArgumentError,
-          "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
+      "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(code)}"
   end
 
   @doc """
@@ -68,12 +72,11 @@ defmodule Kernel.Utils do
     case fields do
       fs when is_list(fs) ->
         :ok
-
       other ->
-        raise ArgumentError, "struct fields definition must be list, got: #{inspect(other)}"
+        raise ArgumentError, "struct fields definition must be list, got: #{inspect other}"
     end
 
-    mapper = fn
+    fields = :lists.map(fn
       {key, val} when is_atom(key) ->
         try do
           Macro.escape(val)
@@ -83,45 +86,15 @@ defmodule Kernel.Utils do
         else
           _ -> {key, val}
         end
-
       key when is_atom(key) ->
         {key, nil}
-
       other ->
-        raise ArgumentError, "struct field names must be atoms, got: #{inspect(other)}"
-    end
+        raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
+    end, fields)
 
-    fields = :lists.map(mapper, fields)
-    enforce_keys = List.wrap(Module.get_attribute(module, :enforce_keys))
-
-    # TODO: Make it raise on v2.0
-    warn_on_duplicate_struct_key(:lists.keysort(1, fields))
-
-    foreach = fn
-      key when is_atom(key) ->
-        :ok
-
-      key ->
-        raise ArgumentError, "keys given to @enforce_keys must be atoms, got: #{inspect(key)}"
-    end
-
-    :lists.foreach(foreach, enforce_keys)
-
-    struct = :maps.put(:__struct__, module, :maps.from_list(fields))
-    {struct, enforce_keys, Module.get_attribute(module, :derive)}
-  end
-
-  defp warn_on_duplicate_struct_key([]) do
-    :ok
-  end
-
-  defp warn_on_duplicate_struct_key([{key, _} | [{key, _} | _] = rest]) do
-    IO.warn("duplicate key #{inspect(key)} found in struct")
-    warn_on_duplicate_struct_key(rest)
-  end
-
-  defp warn_on_duplicate_struct_key([_ | rest]) do
-    warn_on_duplicate_struct_key(rest)
+    {:maps.put(:__struct__, module, :maps.from_list(fields)),
+     List.wrap(Module.get_attribute(module, :enforce_keys)),
+     Module.get_attribute(module, :derive)}
   end
 
   @doc """
@@ -130,7 +103,7 @@ defmodule Kernel.Utils do
   def announce_struct(module) do
     case :erlang.get(:elixir_compiler_pid) do
       :undefined -> :ok
-      pid -> send(pid, {:available, :struct, module})
+      pid -> send(pid, {:struct_available, module})
     end
   end
 
@@ -140,158 +113,14 @@ defmodule Kernel.Utils do
   def raise(msg) when is_binary(msg) do
     RuntimeError.exception(msg)
   end
-
-  def raise(module) when is_atom(module) do
-    module.exception([])
+  def raise(atom) when is_atom(atom) do
+    atom.exception([])
   end
-
-  def raise(%_{__exception__: true} = exception) do
+  def raise(%{__struct__: struct, __exception__: true} = exception) when is_atom(struct) do
     exception
   end
-
   def raise(other) do
-    ArgumentError.exception(
-      "raise/1 and reraise/2 expect a module name, string or exception " <>
-        "as the first argument, got: #{inspect(other)}"
-    )
-  end
-
-  @doc """
-  Callback for defguard.
-
-  Rewrites an expression so it can be used both inside and outside a guard.
-
-  Take, for example, the expression:
-
-      is_integer(value) and rem(value, 2) == 0
-
-  If we wanted to create a macro, `is_even`, from this expression, that could be
-  used in guards, we'd have to take several things into account.
-
-  First, if this expression is being used inside a guard, `value` needs to be
-  unquoted each place it occurs, since it has not yet been at that point in our
-  macro.
-
-  Secondly, if the expression is being used outside of a guard, we want to unquote
-  `value`, but only once, and then re-use the unquoted form throughout the expression.
-
-  This helper does exactly that: takes the AST for an expression and a list of
-  variable references it should be aware of, and rewrites it into a new expression
-  that checks for its presence in a guard, then unquotes the variable references as
-  appropriate.
-
-  The following code
-
-      expression = quote do: is_integer(value) and rem(value, 2) == 0
-      variable_references = [value: Elixir]
-      Kernel.Utils.defguard(expression, variable_references) |> Macro.to_string() |> IO.puts()
-
-  would print a code similar to:
-
-      case Macro.Env.in_guard?(__CALLER__) do
-        true ->
-          quote do
-            is_integer(unquote(value)) and rem(unquote(value), 2) == 0
-          end
-
-        false ->
-          quote do
-            value = unquote(value)
-            is_integer(value) and rem(value, 2) == 0
-          end
-      end
-
-  """
-  defmacro defguard(args, expr) do
-    defguard(args, expr, __CALLER__)
-  end
-
-  @spec defguard([Macro.t()], Macro.t(), Macro.Env.t()) :: Macro.t()
-  def defguard(args, expr, env) do
-    {^args, vars} = extract_refs_from_args(args)
-    env = :elixir_env.with_vars(%{env | context: :guard}, vars)
-    {expr, _scope} = :elixir_expand.expand(expr, env)
-
-    quote do
-      case Macro.Env.in_guard?(__CALLER__) do
-        true -> unquote(literal_quote(unquote_every_ref(expr, vars)))
-        false -> unquote(literal_quote(unquote_refs_once(expr, vars)))
-      end
-    end
-  end
-
-  defp extract_refs_from_args(args) do
-    Macro.postwalk(args, [], fn
-      {ref, meta, context} = var, acc when is_atom(ref) and is_atom(context) ->
-        {var, [{ref, var_context(meta, context)} | acc]}
-
-      node, acc ->
-        {node, acc}
-    end)
-  end
-
-  # Finds every reference to `refs` in `guard` and wraps them in an unquote.
-  defp unquote_every_ref(guard, refs) do
-    Macro.postwalk(guard, fn
-      {ref, meta, context} = var when is_atom(ref) and is_atom(context) ->
-        case {ref, var_context(meta, context)} in refs do
-          true -> literal_unquote(var)
-          false -> var
-        end
-
-      node ->
-        node
-    end)
-  end
-
-  # Prefaces `guard` with unquoted versions of `refs`.
-  defp unquote_refs_once(guard, refs) do
-    {guard, used_refs} =
-      Macro.postwalk(guard, %{}, fn
-        {ref, meta, context} = var, acc when is_atom(ref) and is_atom(context) ->
-          pair = {ref, var_context(meta, context)}
-
-          case pair in refs do
-            true ->
-              case acc do
-                %{^pair => {new_var, _}} ->
-                  {new_var, acc}
-
-                %{} ->
-                  generated = String.to_atom("arg" <> Integer.to_string(map_size(acc)))
-                  new_var = Macro.var(generated, Elixir)
-                  {new_var, Map.put(acc, pair, {new_var, var})}
-              end
-
-            false ->
-              {var, acc}
-          end
-
-        node, acc ->
-          {node, acc}
-      end)
-
-    all_used = for ref <- :lists.reverse(refs), used = :maps.get(ref, used_refs, nil), do: used
-    {vars, exprs} = :lists.unzip(all_used)
-
-    quote do
-      {unquote_splicing(vars)} = {unquote_splicing(Enum.map(exprs, &literal_unquote/1))}
-      unquote(guard)
-    end
-  end
-
-  defp literal_quote(ast) do
-    {:quote, [], [[do: ast]]}
-  end
-
-  defp literal_unquote(ast) do
-    {:unquote, [], List.wrap(ast)}
-  end
-
-  defp var_context(meta, kind) do
-    case :lists.keyfind(:counter, 1, meta) do
-      {:counter, counter} -> counter
-      false -> kind
-    end
+    ArgumentError.exception("raise/1 expects an alias, string or exception as " <>
+                            "the first argument, got: #{inspect other}")
   end
 end

lib/elixir/lib/keyword.ex

@@ -1,82 +1,31 @@
 defmodule Keyword do
   @moduledoc """
-  Keyword lists are lists of two-element tuples, where the first
-  element of the tuple is an atom and the second element can be any
-  value, used mostly to work with optional values.
+  A set of functions for working with keywords.
 
-  ## Examples
+  A keyword is a list of two-element tuples where the first
+  element of the tuple is an atom and the second element
+  can be any value.
 
-  For example, the following is a keyword list:
+  A keyword may have duplicated keys so it is not strictly
+  a key-value store. However most of the functions in this module
+  behave exactly as a dictionary so they work similarly to
+  the functions you would find in the `Map` module.
 
-      [{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]
+  For example, `Keyword.get/3` will get the first entry matching
+  the given key, regardless if duplicated entries exist.
+  Similarly, `Keyword.put/3` and `Keyword.delete/3` ensure all
+  duplicated entries for a given key are removed when invoked.
 
-  Elixir provides a special and more concise syntax for keyword lists
-  that looks like this:
+  A handful of functions exist to handle duplicated keys, in
+  particular, `Enum.into/2` allows creating new keywords without
+  removing duplicated keys, `get_values/2` returns all values for
+  a given key and `delete_first/2` deletes just one of the existing
+  entries.
 
-      [exit_on_close: true, active: :once, packet_size: 1024]
-
-  The two syntaxes are completely equivalent. Like atoms, keyword
-  lists keys must be composed of Unicode characters such as letters,
-  numbers, underscore, and `@`. If the keyword has a character that
-  does not belong to the category above, such as spaces, you can wrap
-  it in quotes:
-
-      iex> ["exit on close": true]
-      ["exit on close": true]
-
-  Wrapping a keyword in quotes does not make it a string. Keyword lists
-  keys are always atoms. If you use quotes around the key when quoting
-  is not necessary, Elixir will warn.
-
-  ## Duplicate keys and ordering
-
-  A keyword may have duplicated keys so it is not strictly a key-value
-  data type. However most of the functions in this module behave exactly
-  as a key-value so they work similarly to the functions you would find
-  in the `Map` module. For example, `Keyword.get/3` will get the first
-  entry matching the given key, regardless if duplicated entries exist.
-  Similarly, `Keyword.put/3` and `Keyword.delete/2` ensure all duplicated
-  entries for a given key are removed when invoked. Note however that
-  keyword list operations need to traverse the list in order to find
-  keys, so these operations are slower than their map counterparts.
-
-  A handful of functions exist to handle duplicated keys, for example,
-  `get_values/2` returns all values for a given key and `delete_first/2`
-  deletes just one of the existing entries.
-
-  The functions in `Keyword` do not guarantee any property when it comes
-  to ordering. However, since a keyword list is simply a list, all the
-  operations defined in `Enum` and `List` can be applied too, especially
-  when ordering is required.
-
-  Most of the functions in this module work in linear time. This means
-  that, the time it takes to perform an operation grows at the same
-  rate as the length of the list.
-
-  ## Call syntax
-
-  When keyword lists are passed as the last argument to a function, then
-  the square brackets around the keyword list can be omitted as well. For
-  example, the keyword list syntax:
-
-      String.split("1-0", "-", [trim: true, parts: 2])
-
-  can be written without the enclosing brackets whenever it is the last
-  argument of a function call:
-
-      String.split("1-0", "-", trim: true, parts: 2)
-
-  Since tuples, lists, maps, and others are treated the same as function
-  calls in Elixir syntax, this property is also available to them:
-
-      iex> {1, 2, foo: :bar}
-      {1, 2, [{:foo, :bar}]}
-
-      iex> [1, 2, foo: :bar]
-      [1, 2, {:foo, :bar}]
-
-      iex> %{1 => 2, foo: :bar}
-      %{1 => 2, :foo => :bar}
+  The functions in Keyword do not guarantee any property when
+  it comes to ordering. However, since a keyword list is simply a
+  list, all the operations defined in `Enum` and `List` can be
+  applied too, especially when ordering is required.
   """
 
   @compile :inline_list_funcs
@@ -94,7 +43,7 @@ defmodule Keyword do
 
       iex> Keyword.keyword?([])
       true
-      iex> Keyword.keyword?(a: 1)
+      iex> Keyword.keyword?([a: 1])
       true
       iex> Keyword.keyword?([{Foo, 1}])
       true
@@ -110,7 +59,7 @@ defmodule Keyword do
   def keyword?(term)
 
   def keyword?([{key, _value} | rest]) when is_atom(key), do: keyword?(rest)
-  def keyword?([]), do: true
+  def keyword?([]),     do: true
   def keyword?(_other), do: false
 
   @doc """
@@ -126,7 +75,7 @@ defmodule Keyword do
   def new, do: []
 
   @doc """
-  Creates a keyword list from an enumerable.
+  Creates a keyword from an enumerable.
 
   Duplicated entries are removed, the latest one prevails.
   Unlike `Enum.into(enumerable, [])`, `Keyword.new(enumerable)`
@@ -141,13 +90,13 @@ defmodule Keyword do
       [a: 3]
 
   """
-  @spec new(Enum.t()) :: t
+  @spec new(Enum.t) :: t
   def new(pairs) do
     new(pairs, fn pair -> pair end)
   end
 
   @doc """
-  Creates a keyword list from an enumerable via the transformation function.
+  Creates a keyword from an enumerable via the transformation function.
 
   Duplicated entries are removed, the latest one prevails.
   Unlike `Enum.into(enumerable, [], fun)`,
@@ -155,17 +104,16 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.new([:a, :b], fn x -> {x, x} end)
+      iex> Keyword.new([:a, :b], fn(x) -> {x, x} end)
       [a: :a, b: :b]
 
   """
-  @spec new(Enum.t(), (term -> {key, value})) :: t
-  def new(pairs, transform) when is_function(transform, 1) do
+  @spec new(Enum.t, (term -> {key, value})) :: t
+  def new(pairs, transform) do
     fun = fn el, acc ->
       {k, v} = transform.(el)
       put_new(acc, k, v)
     end
-
     :lists.foldl(fun, [], Enum.reverse(pairs))
   end
 
@@ -197,6 +145,7 @@ defmodule Keyword do
       3
 
   """
+  @spec get(t, key) :: value
   @spec get(t, key, value) :: value
   def get(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
@@ -272,32 +221,29 @@ defmodule Keyword do
   """
   @spec get_and_update(t, key, (value -> {get, value} | :pop)) :: {get, t} when get: term
   def get_and_update(keywords, key, fun)
-      when is_list(keywords) and is_atom(key),
-      do: get_and_update(keywords, [], key, fun)
+    when is_list(keywords) and is_atom(key),
+    do: get_and_update(keywords, [], key, fun)
 
   defp get_and_update([{key, current} | t], acc, key, fun) do
     case fun.(current) do
       {get, value} ->
         {get, :lists.reverse(acc, [{key, value} | t])}
-
       :pop ->
         {current, :lists.reverse(acc, t)}
-
       other ->
         raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
     end
   end
 
-  defp get_and_update([{_, _} = h | t], acc, key, fun), do: get_and_update(t, [h | acc], key, fun)
+  defp get_and_update([{_, _} = h | t], acc, key, fun),
+    do: get_and_update(t, [h | acc], key, fun)
 
   defp get_and_update([], acc, key, fun) do
     case fun.(nil) do
       {get, update} ->
         {get, [{key, update} | :lists.reverse(acc)]}
-
       :pop ->
         {nil, :lists.reverse(acc)}
-
       other ->
         raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
     end
@@ -332,7 +278,7 @@ defmodule Keyword do
       {1, []}
 
   """
-  @spec get_and_update!(t, key, (value -> {get, value})) :: {get, t} when get: term
+  @spec get_and_update!(t, key, (value -> {get, value})) :: {get, t} | no_return when get: term
   def get_and_update!(keywords, key, fun) do
     get_and_update!(keywords, key, fun, [])
   end
@@ -341,10 +287,8 @@ defmodule Keyword do
     case fun.(value) do
       {get, value} ->
         {get, :lists.reverse(acc, [{key, value} | delete(keywords, key)])}
-
       :pop ->
         {value, :lists.reverse(acc, keywords)}
-
       other ->
         raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
     end
@@ -392,7 +336,7 @@ defmodule Keyword do
       ** (KeyError) key :b not found in: [a: 1]
 
   """
-  @spec fetch!(t, key) :: value
+  @spec fetch!(t, key) :: value | no_return
   def fetch!(keywords, key) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, value} -> value
@@ -415,13 +359,13 @@ defmodule Keyword do
   """
   @spec get_values(t, key) :: [value]
   def get_values(keywords, key) when is_list(keywords) and is_atom(key) do
-    get_values(keywords, key, [])
+    fun = fn
+      {^key, val} -> {true, val}
+      {_, _} -> false
+    end
+    :lists.filtermap(fun, keywords)
   end
 
-  defp get_values([{key, value} | tail], key, values), do: get_values(tail, key, [value | values])
-  defp get_values([{_, _} | tail], key, values), do: get_values(tail, key, values)
-  defp get_values([], _key, values), do: :lists.reverse(values)
-
   @doc """
   Returns all keys from the keyword list.
 
@@ -429,9 +373,9 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.keys(a: 1, b: 2)
+      iex> Keyword.keys([a: 1, b: 2])
       [:a, :b]
-      iex> Keyword.keys(a: 1, b: 2, a: 3)
+      iex> Keyword.keys([a: 1, b: 2, a: 3])
       [:a, :b, :a]
 
   """
@@ -447,9 +391,9 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.values(a: 1, b: 2)
+      iex> Keyword.values([a: 1, b: 2])
       [1, 2]
-      iex> Keyword.values(a: 1, b: 2, a: 3)
+      iex> Keyword.values([a: 1, b: 2, a: 3])
       [1, 2, 3]
 
   """
@@ -458,25 +402,26 @@ defmodule Keyword do
     :lists.map(fn {_, v} -> v end, keywords)
   end
 
-  @doc false
-  @deprecated "Use Keyword.fetch/2 + Keyword.delete/2 instead"
+  @doc """
+  Deletes the entries in the keyword list for a `key` with `value`.
+
+  If no `key` with `value` exists, returns the keyword list unchanged.
+
+  ## Examples
+
+      iex> Keyword.delete([a: 1, b: 2], :a, 1)
+      [b: 2]
+      iex> Keyword.delete([a: 1, b: 2, a: 3], :a, 3)
+      [a: 1, b: 2]
+      iex> Keyword.delete([a: 1], :a, 5)
+      [a: 1]
+      iex> Keyword.delete([a: 1], :b, 5)
+      [a: 1]
+
+  """
+  @spec delete(t, key, value) :: t
   def delete(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keymember(key, 1, keywords) do
-      true -> delete_key_value(keywords, key, value)
-      _ -> keywords
-    end
-  end
-
-  defp delete_key_value([{key, value} | tail], key, value) do
-    delete_key_value(tail, key, value)
-  end
-
-  defp delete_key_value([{_, _} = pair | tail], key, value) do
-    [pair | delete_key_value(tail, key, value)]
-  end
-
-  defp delete_key_value([], _key, _value) do
-    []
+    :lists.filter(fn {k, v} -> k != key or v != value end, keywords)
   end
 
   @doc """
@@ -497,18 +442,10 @@ defmodule Keyword do
 
   """
   @spec delete(t, key) :: t
-  @compile {:inline, delete: 2}
   def delete(keywords, key) when is_list(keywords) and is_atom(key) do
-    case :lists.keymember(key, 1, keywords) do
-      true -> delete_key(keywords, key)
-      _ -> keywords
-    end
+    :lists.filter(fn {k, _} -> k != key end, keywords)
   end
 
-  defp delete_key([{key, _} | tail], key), do: delete_key(tail, key)
-  defp delete_key([{_, _} = pair | tail], key), do: [pair | delete_key(tail, key)]
-  defp delete_key([], _key), do: []
-
   @doc """
   Deletes the first entry in the keyword list for a specific `key`.
 
@@ -524,22 +461,7 @@ defmodule Keyword do
   """
   @spec delete_first(t, key) :: t
   def delete_first(keywords, key) when is_list(keywords) and is_atom(key) do
-    case :lists.keymember(key, 1, keywords) do
-      true -> delete_first_key(keywords, key)
-      _ -> keywords
-    end
-  end
-
-  defp delete_first_key([{key, _} | tail], key) do
-    tail
-  end
-
-  defp delete_first_key([{_, _} = pair | tail], key) do
-    [pair | delete_first_key(tail, key)]
-  end
-
-  defp delete_first_key([], _key) do
-    []
+    :lists.keydelete(key, 1, keywords)
   end
 
   @doc """
@@ -612,50 +534,6 @@ defmodule Keyword do
     end
   end
 
-  @doc false
-  @deprecated "Use Keyword.fetch/2 + Keyword.put/3 instead"
-  def replace(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> [{key, value} | delete(keywords, key)]
-      false -> keywords
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in `keywords`.
-
-  If `key` is not present in `keywords`, a `KeyError` exception is raised.
-
-  ## Examples
-
-      iex> Keyword.replace!([a: 1, b: 2, a: 3], :a, :new)
-      [a: :new, b: 2]
-      iex> Keyword.replace!([a: 1, b: 2, c: 3, b: 4], :b, :new)
-      [a: 1, b: :new, c: 3]
-
-      iex> Keyword.replace!([a: 1], :b, 2)
-      ** (KeyError) key :b not found in: [a: 1]
-
-  """
-  @doc since: "1.5.0"
-  @spec replace!(t, key, value) :: t
-  def replace!(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    replace!(keywords, key, value, keywords)
-  end
-
-  defp replace!([{key, _} | keywords], key, value, _original) do
-    [{key, value} | delete(keywords, key)]
-  end
-
-  defp replace!([{_, _} = e | keywords], key, value, original) do
-    [e | replace!(keywords, key, value, original)]
-  end
-
-  defp replace!([], key, _value, original) when is_atom(key) do
-    raise(KeyError, key: key, term: original)
-  end
-
   @doc """
   Checks if two keywords are equal.
 
@@ -698,26 +576,17 @@ defmodule Keyword do
 
   """
   @spec merge(t, t) :: t
-  def merge(keywords1, keywords2)
-
-  def merge(keywords1, []) when is_list(keywords1), do: keywords1
-  def merge([], keywords2) when is_list(keywords2), do: keywords2
-
   def merge(keywords1, keywords2) when is_list(keywords1) and is_list(keywords2) do
     if keyword?(keywords2) do
       fun = fn
         {key, _value} when is_atom(key) ->
           not has_key?(keywords2, key)
-
         _ ->
-          raise ArgumentError,
-                "expected a keyword list as the first argument, got: #{inspect(keywords1)}"
+          raise ArgumentError, message: "expected a keyword list as the first argument, got: #{inspect keywords1}"
       end
-
       :lists.filter(fun, keywords1) ++ keywords2
     else
-      raise ArgumentError,
-            "expected a keyword list as the second argument, got: #{inspect(keywords2)}"
+      raise ArgumentError, message: "expected a keyword list as the second argument, got: #{inspect keywords2}"
     end
   end
 
@@ -740,38 +609,35 @@ defmodule Keyword do
       [b: 2, a: 4, d: 4]
 
       iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
-      ...>   v1 + v2
+      ...>  v1 + v2
       ...> end)
       [b: 2, a: 4, d: 4, a: 5]
 
       iex> Keyword.merge([a: 1, b: 2, a: 3], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
-      ...>   v1 + v2
+      ...>  v1 + v2
       ...> end)
       [b: 2, a: 4, d: 4, a: 8]
 
       iex> Keyword.merge([a: 1, b: 2], [:a, :b], fn :a, v1, v2 ->
-      ...>   v1 + v2
+      ...>  v1 + v2
       ...> end)
       ** (ArgumentError) expected a keyword list as the second argument, got: [:a, :b]
 
   """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(keywords1, keywords2, fun)
-      when is_list(keywords1) and is_list(keywords2) and is_function(fun, 3) do
+  def merge(keywords1, keywords2, fun) when is_list(keywords1) and is_list(keywords2) and is_function(fun, 3) do
     if keyword?(keywords1) do
       do_merge(keywords2, [], keywords1, keywords1, fun, keywords2)
     else
-      raise ArgumentError,
-            "expected a keyword list as the first argument, got: #{inspect(keywords1)}"
+      raise ArgumentError, message: "expected a keyword list as the first argument, got: #{inspect keywords1}"
     end
   end
 
   defp do_merge([{key, value2} | tail], acc, rest, original, fun, keywords2) when is_atom(key) do
     case :lists.keyfind(key, 1, original) do
       {^key, value1} ->
-        acc = [{key, fun.(key, value1, value2)} | acc]
-        original = :lists.keydelete(key, 1, original)
-        do_merge(tail, acc, delete(rest, key), original, fun, keywords2)
+        do_merge(tail, [{key, fun.(key, value1, value2)} | acc],
+                 delete(rest, key), :lists.keydelete(key, 1, original), fun, keywords2)
 
       false ->
         do_merge(tail, [{key, value2} | acc], rest, original, fun, keywords2)
@@ -783,8 +649,7 @@ defmodule Keyword do
   end
 
   defp do_merge(_other, _acc, _rest, _original, _fun, keywords2) do
-    raise ArgumentError,
-          "expected a keyword list as the second argument, got: #{inspect(keywords2)}"
+    raise ArgumentError, message: "expected a keyword list as the second argument, got: #{inspect keywords2}"
   end
 
   @doc """
@@ -813,31 +678,30 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.update!([a: 1, b: 2, a: 3], :a, &(&1 * 2))
-      [a: 2, b: 2]
-      iex> Keyword.update!([a: 1, b: 2, c: 3], :b, &(&1 * 2))
-      [a: 1, b: 4, c: 3]
+      iex> Keyword.update!([a: 1], :a, &(&1 * 2))
+      [a: 2]
+      iex> Keyword.update!([a: 1, a: 2], :a, &(&1 * 2))
+      [a: 2]
 
       iex> Keyword.update!([a: 1], :b, &(&1 * 2))
       ** (KeyError) key :b not found in: [a: 1]
 
   """
-  @spec update!(t, key, (value -> value)) :: t
-  def update!(keywords, key, fun)
-      when is_list(keywords) and is_atom(key) and is_function(fun, 1) do
+  @spec update!(t, key, (value -> value)) :: t | no_return
+  def update!(keywords, key, fun) do
     update!(keywords, key, fun, keywords)
   end
 
-  defp update!([{key, value} | keywords], key, fun, _original) do
+  defp update!([{key, value} | keywords], key, fun, _dict) do
     [{key, fun.(value)} | delete(keywords, key)]
   end
 
-  defp update!([{_, _} = e | keywords], key, fun, original) do
-    [e | update!(keywords, key, fun, original)]
+  defp update!([{_, _} = e | keywords], key, fun, dict) do
+    [e | update!(keywords, key, fun, dict)]
   end
 
-  defp update!([], key, _fun, original) when is_atom(key) do
-    raise(KeyError, key: key, term: original)
+  defp update!([], key, _fun, dict) when is_atom(key) do
+    raise(KeyError, key: key, term: dict)
   end
 
   @doc """
@@ -892,10 +756,10 @@ defmodule Keyword do
 
   """
   @spec split(t, [key]) :: {t, t}
-  def split(keywords, keys) when is_list(keywords) and is_list(keys) do
+  def split(keywords, keys) when is_list(keywords) do
     fun = fn {k, v}, {take, drop} ->
       case k in keys do
-        true -> {[{k, v} | take], drop}
+        true  -> {[{k, v} | take], drop}
         false -> {take, [{k, v} | drop]}
       end
     end
@@ -920,7 +784,7 @@ defmodule Keyword do
 
   """
   @spec take(t, [key]) :: t
-  def take(keywords, keys) when is_list(keywords) and is_list(keys) do
+  def take(keywords, keys) when is_list(keywords) do
     :lists.filter(fn {k, _} -> k in keys end, keywords)
   end
 
@@ -938,20 +802,15 @@ defmodule Keyword do
 
   """
   @spec drop(t, [key]) :: t
-  def drop(keywords, keys) when is_list(keywords) and is_list(keys) do
-    :lists.filter(fn {key, _} -> key not in keys end, keywords)
+  def drop(keywords, keys) when is_list(keywords) do
+    :lists.filter(fn {k, _} -> not k in keys end, keywords)
   end
 
   @doc """
-  Returns the first value for `key` and removes all associated entries in the keyword list.
+  Returns and removes all values associated with `key` in the keyword list.
 
-  It returns a tuple where the first element is the first value for `key` and the
-  second element is a keyword list with all entries associated with `key` removed.
-  If the `key` is not present in the keyword list, `{default, keyword_list}` is
-  returned.
-
-  If you don't want to remove all the entries associated with `key` use `pop_first/3`
-  instead, that function will remove only the first entry.
+  All duplicated keys are removed. See `pop_first/3` for
+  removing only the first entry.
 
   ## Examples
 
@@ -966,75 +825,15 @@ defmodule Keyword do
 
   """
   @spec pop(t, key, value) :: {value, t}
-  def pop(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
+  def pop(keywords, key, default \\ nil) when is_list(keywords) do
     case fetch(keywords, key) do
-      {:ok, value} -> {value, delete(keywords, key)}
-      :error -> {default, keywords}
+      {:ok, value} ->
+        {value, delete(keywords, key)}
+      :error ->
+        {default, keywords}
     end
   end
 
-  @doc """
-  Returns the first value for `key` and removes all associated antries in the keyword list,
-  raising if `key` is not present.
-
-  This function behaves like `pop/3`, but raises in cases the `key` is not present in the
-  given `keywords`.
-
-  ## Examples
-
-      iex> Keyword.pop!([a: 1], :a)
-      {1, []}
-      iex> Keyword.pop!([a: 1, a: 2], :a)
-      {1, []}
-      iex> Keyword.pop!([a: 1], :b)
-      ** (KeyError) key :b not found in: [a: 1]
-
-  """
-  @doc since: "1.10.0"
-  @spec pop!(t, key) :: {value, t}
-  def pop!(keywords, key) when is_list(keywords) and is_atom(key) do
-    case fetch(keywords, key) do
-      {:ok, value} -> {value, delete(keywords, key)}
-      :error -> raise KeyError, key: key, term: keywords
-    end
-  end
-
-  @doc """
-  Returns all values for `key` and removes all associated entries in the keyword list.
-
-  It returns a tuple where the first element is a list of values for `key` and the
-  second element is a keyword list with all entries associated with `key` removed.
-  If the `key` is not present in the keyword list, `{[], keyword_list}` is
-  returned.
-
-  If you don't want to remove all the entries associated with `key` use `pop_first/3`
-  instead, that function will remove only the first entry.
-
-  ## Examples
-
-      iex> Keyword.pop_values([a: 1], :a)
-      {[1], []}
-      iex> Keyword.pop_values([a: 1], :b)
-      {[], [a: 1]}
-      iex> Keyword.pop_values([a: 1, a: 2], :a)
-      {[1, 2], []}
-
-  """
-  @doc since: "1.10.0"
-  @spec pop_values(t, key) :: {[value], t}
-  def pop_values(keywords, key) when is_list(keywords) and is_atom(key) do
-    pop_values(:lists.reverse(keywords), key, [], [])
-  end
-
-  defp pop_values([{key, value} | tail], key, values, acc),
-    do: pop_values(tail, key, [value | values], acc)
-
-  defp pop_values([{_, _} = pair | tail], key, values, acc),
-    do: pop_values(tail, key, values, [pair | acc])
-
-  defp pop_values([], _key, values, acc),
-    do: {values, acc}
-
   @doc """
   Lazily returns and removes all values associated with `key` in the keyword list.
 
@@ -1059,11 +858,10 @@ defmodule Keyword do
   """
   @spec pop_lazy(t, key, (() -> value)) :: {value, t}
   def pop_lazy(keywords, key, fun)
-      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
+      when is_list(keywords) and is_function(fun, 0) do
     case fetch(keywords, key) do
       {:ok, value} ->
         {value, delete(keywords, key)}
-
       :error ->
         {fun.(), keywords}
     end
@@ -1087,7 +885,7 @@ defmodule Keyword do
 
   """
   @spec pop_first(t, key, value) :: {value, t}
-  def pop_first(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
+  def pop_first(keywords, key, default \\ nil) when is_list(keywords) do
     case :lists.keytake(key, 1, keywords) do
       {:value, {^key, value}, rest} -> {value, rest}
       false -> {default, keywords}
@@ -1099,7 +897,7 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.to_list(a: 1)
+      iex> Keyword.to_list([a: 1])
       [a: 1]
 
   """
@@ -1109,8 +907,9 @@ defmodule Keyword do
   end
 
   @doc false
-  @deprecated "Use Kernel.length/1 instead"
+  # TODO: Remove on 2.0
   def size(keyword) do
+    IO.warn "Keyword.size/1 is deprecated, please use Kernel.length/1"
     length(keyword)
   end
 end

lib/elixir/lib/list.ex

@@ -1,6 +1,6 @@
 defmodule List do
   @moduledoc """
-  Linked lists hold zero, one, or more elements in the choosen order.
+  Functions that work on (linked) lists.
 
   Lists in Elixir are specified between square brackets:
 
@@ -45,89 +45,65 @@ defmodule List do
   slower as the list grows in size (linear time):
 
       iex> list = [1, 2, 3]
-      iex> [0 | list] # fast
+      iex> [0 | list]   # fast
       [0, 1, 2, 3]
-      iex> list ++ [4] # slow
+      iex> list ++ [4]  # slow
       [1, 2, 3, 4]
 
-  Most of the functions in this module work in linear time. This means that,
-  that the time it takes to perform an operation grows at the same rate as the
-  length of the list. For example `length/1` and `last/1` will run in linear
-  time because they need to iterate through every element of the list, but
-  `first/1` will run in constant time because it only needs the first element.
-
-  Lists also implement the `Enumerable` protocol, so many functions to work with
-  lists are found in the `Enum` module. Additionally, the following functions and
-  operators for lists are found in `Kernel`:
-
-    * `++/2`
-    * `--/2`
-    * `hd/1`
-    * `tl/1`
-    * `in/2`
-    * `length/1`
+  The `Kernel` module contains many functions to manipulate lists
+  and that are allowed in guards. For example, `Kernel.hd/1` to
+  retrieve the head, `Kernel.tl/1` to fetch the tail and
+  `Kernel.length/1` for calculating the length. Keep in mind that,
+  similar to appending to a list, calculating the length needs to
+  traverse the whole list.
 
   ## Charlists
 
-  If a list is made of non-negative integers, where each integer represents a
-  Unicode code point, the list can also be called a charlist. These integers
-  must:
-
-    * be within the range `0..0x10FFFF` (`0..1_114_111`);
-    * and be out of the range `0xD800..0xDFFF` (`55_296..57_343`), which is
-      reserved in Unicode for UTF-16 surrogate pairs.
-
-  Elixir uses single quotes to define charlists:
+  If a list is made of non-negative integers, it can also be called
+  a charlist. Elixir uses single quotes to define charlists:
 
       iex> 'héllo'
       [104, 233, 108, 108, 111]
 
-  In particular, charlists will be printed back by default in single
-  quotes if they contain only printable ASCII characters:
+  In particular, charlists may be printed back in single
+  quotes if they contain only ASCII-printable codepoints:
 
       iex> 'abc'
       'abc'
 
-  Even though the representation changed, the raw data does remain a list of
-  numbers, which can be handled as such:
-
-      iex> inspect('abc', charlists: :as_list)
-      "[97, 98, 99]"
-      iex> Enum.map('abc', fn num -> 1000 + num end)
-      [1097, 1098, 1099]
-
-  You can use the `IEx.Helpers.i/1` helper to get a condensed rundown on
-  charlists in IEx when you encounter them, which shows you the type, description
-  and also the raw representation in one single summary.
-
   The rationale behind this behaviour is to better support
   Erlang libraries which may return text as charlists
-  instead of Elixir strings. In Erlang, charlists are the default
-  way of handling strings, while in Elixir it's binaries. One
-  example of such functions is `Application.loaded_applications/0`:
+  instead of Elixir strings. One example of such functions
+  is `Application.loaded_applications/0`:
 
-      Application.loaded_applications()
-      #=>  [
-      #=>    {:stdlib, 'ERTS  CXC 138 10', '2.6'},
-      #=>    {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
-      #=>    {:elixir, 'elixir', '1.0.0'},
-      #=>    {:kernel, 'ERTS  CXC 138 10', '4.1'},
-      #=>    {:logger, 'logger', '1.0.0'}
-      #=>  ]
+      Application.loaded_applications
+      #=>  [{:stdlib, 'ERTS  CXC 138 10', '2.6'},
+            {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
+            {:elixir, 'elixir', '1.0.0'},
+            {:kernel, 'ERTS  CXC 138 10', '4.1'},
+            {:logger, 'logger', '1.0.0'}]
 
-  A list can be checked if it is made of only printable ASCII
-  characters with `ascii_printable?/2`.
+  ## List and Enum modules
 
-  Improper lists are never deemed as charlists.
+  This module aims to provide operations that are specific
+  to lists, like conversion between data types, updates,
+  deletions and key lookups (for lists of tuples). For traversing
+  lists in general, developers should use the functions in the
+  `Enum` module that work across a variety of data types.
+
+  In both `Enum` and `List` modules, any kind of index access
+  on a list is linear. Negative indexes are also supported but
+  they imply the list will be iterated twice, one to calculate
+  the proper index and another to perform the operation.
   """
 
   @compile :inline_list_funcs
 
   @doc """
-  Deletes the given `element` from the `list`. Returns a new list without
-  the element.
+  Deletes the given `item` from the `list`. Returns a new list without
+  the item.
 
-  If the `element` occurs more than once in the `list`, just
+  If the `item` occurs more than once in the `list`, just
   the first occurrence is removed.
 
   ## Examples
@@ -135,47 +111,28 @@ defmodule List do
       iex> List.delete([:a, :b, :c], :a)
       [:b, :c]
 
-      iex> List.delete([:a, :b, :c], :d)
-      [:a, :b, :c]
-
       iex> List.delete([:a, :b, :b, :c], :b)
       [:a, :b, :c]
 
-      iex> List.delete([], :b)
-      []
-
   """
-  @spec delete([], any) :: []
-  @spec delete([...], any) :: list
-  def delete(list, element)
-  def delete([element | list], element), do: list
-  def delete([other | list], element), do: [other | delete(list, element)]
-  def delete([], _element), do: []
+  @spec delete(list, any) :: list
+  def delete(list, item) do
+    :lists.delete(item, list)
+  end
 
   @doc """
   Duplicates the given element `n` times in a list.
 
-  `n` is an integer greater than or equal to `0`.
-
-  If `n` is `0`, an empty list is returned.
-
   ## Examples
 
-      iex> List.duplicate("hello", 0)
-      []
+      iex> List.duplicate("hello", 3)
+      ["hello", "hello", "hello"]
 
-      iex> List.duplicate("hi", 1)
-      ["hi"]
-
-      iex> List.duplicate("bye", 2)
-      ["bye", "bye"]
-
-      iex> List.duplicate([1, 2], 3)
-      [[1, 2], [1, 2], [1, 2]]
+      iex> List.duplicate([1, 2], 2)
+      [[1, 2], [1, 2]]
 
   """
-  @spec duplicate(any, 0) :: []
-  @spec duplicate(elem, pos_integer) :: [elem, ...] when elem: var
+  @spec duplicate(elem, non_neg_integer) :: [elem] when elem: var
   def duplicate(elem, n) do
     :lists.duplicate(n, elem)
   end
@@ -183,16 +140,11 @@ defmodule List do
   @doc """
   Flattens the given `list` of nested lists.
 
-  Empty list elements are discarded.
-
   ## Examples
 
       iex> List.flatten([1, [[2], 3]])
       [1, 2, 3]
 
-      iex> List.flatten([[], [[], []]])
-      []
-
   """
   @spec flatten(deep_list) :: list when deep_list: [any | deep_list]
   def flatten(list) do
@@ -204,17 +156,11 @@ defmodule List do
   The list `tail` will be added at the end of
   the flattened list.
 
-  Empty list elements from `list` are discarded,
-  but not the ones from `tail`.
-
   ## Examples
 
       iex> List.flatten([1, [[2], 3]], [4, 5])
       [1, 2, 3, 4, 5]
 
-      iex> List.flatten([1, [], 2], [3, [], 4])
-      [1, 2, 3, [], 4]
-
   """
   @spec flatten(deep_list, [elem]) :: [elem] when elem: var, deep_list: [elem | deep_list]
   def flatten(list, tail) do
@@ -227,16 +173,16 @@ defmodule List do
 
   ## Examples
 
-      iex> List.foldl([5, 5], 10, fn x, acc -> x + acc end)
+      iex> List.foldl([5, 5], 10, fn(x, acc) -> x + acc end)
       20
 
-      iex> List.foldl([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
+      iex> List.foldl([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
       2
 
   """
   @spec foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldl(list, acc, fun) when is_list(list) and is_function(fun) do
-    :lists.foldl(fun, acc, list)
+  def foldl(list, acc, function) when is_list(list) and is_function(function) do
+    :lists.foldl(function, acc, list)
   end
 
   @doc """
@@ -245,13 +191,13 @@ defmodule List do
 
   ## Examples
 
-      iex> List.foldr([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
+      iex> List.foldr([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
       -2
 
   """
   @spec foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldr(list, acc, fun) when is_list(list) and is_function(fun) do
-    :lists.foldr(fun, acc, list)
+  def foldr(list, acc, function) when is_list(list) and is_function(function) do
+    :lists.foldr(function, acc, list)
   end
 
   @doc """
@@ -269,9 +215,8 @@ defmodule List do
       1
 
   """
-  @spec first([]) :: nil
-  @spec first([elem, ...]) :: elem when elem: var
-  def first([]), do: nil
+  @spec first([elem]) :: nil | elem when elem: var
+  def first([]),      do: nil
   def first([head | _]), do: head
 
   @doc """
@@ -289,19 +234,16 @@ defmodule List do
       3
 
   """
-  @spec last([]) :: nil
-  @spec last([elem, ...]) :: elem when elem: var
+  @spec last([elem]) :: nil | elem when elem: var
   def last([]), do: nil
   def last([head]), do: head
   def last([_ | tail]), do: last(tail)
 
   @doc """
   Receives a list of tuples and returns the first tuple
-  where the element at `position` in the tuple matches the
+  where the item at `position` in the tuple matches the
   given `key`.
 
-  If no matching tuple is found, `default` is returned.
-
   ## Examples
 
       iex> List.keyfind([a: 1, b: 2], :a, 0)
@@ -321,7 +263,7 @@ defmodule List do
 
   @doc """
   Receives a list of tuples and returns `true` if there is
-  a tuple where the element at `position` in the tuple matches
+  a tuple where the item at `position` in the tuple matches
   the given `key`.
 
   ## Examples
@@ -342,17 +284,14 @@ defmodule List do
   end
 
   @doc """
-  Receives a list of tuples and if the identified element by `key` at `position`
-  exists, it is replaced with `new_tuple`.
+  Receives a list of tuples and replaces the item
+  identified by `key` at `position` if it exists.
 
   ## Examples
 
       iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
       [a: 3, b: 2]
 
-      iex> List.keyreplace([a: 1, b: 2], :a, 1, {:a, 3})
-      [a: 1, b: 2]
-
   """
   @spec keyreplace([tuple], any, non_neg_integer, tuple) :: [tuple]
   def keyreplace(list, key, position, new_tuple) do
@@ -360,7 +299,7 @@ defmodule List do
   end
 
   @doc """
-  Receives a list of tuples and sorts the elements
+  Receives a list of tuples and sorts the items
   at `position` of the tuples. The sort is stable.
 
   ## Examples
@@ -378,10 +317,10 @@ defmodule List do
   end
 
   @doc """
-  Receives a `list` of tuples and replaces the element
-  identified by `key` at `position` with `new_tuple`.
+  Receives a `list` of tuples and replaces the item
+  identified by `key` at `position`.
 
-  If the element does not exist, it is added to the end of the `list`.
+  If the item does not exist, it is added to the end of the `list`.
 
   ## Examples
 
@@ -399,7 +338,7 @@ defmodule List do
 
   @doc """
   Receives a `list` of tuples and deletes the first tuple
-  where the element at `position` matches the
+  where the item at `position` matches the
   given `key`. Returns the new list.
 
   ## Examples
@@ -441,16 +380,16 @@ defmodule List do
   @spec keytake([tuple], any, non_neg_integer) :: {tuple, [tuple]} | nil
   def keytake(list, key, position) do
     case :lists.keytake(key, position + 1, list) do
-      {:value, element, list} -> {element, list}
-      false -> nil
+      {:value, item, list} -> {item, list}
+      false                -> nil
     end
   end
 
   @doc """
-  Wraps `term` in a list if this is not list.
+  Wraps the argument in a list.
 
-  If `term` is already a list, it returns the list.
-  If `term` is `nil`, it returns an empty list.
+  If the argument is already a list, returns the list.
+  If the argument is `nil`, returns an empty list.
 
   ## Examples
 
@@ -464,9 +403,7 @@ defmodule List do
       []
 
   """
-  @spec wrap(term) :: maybe_improper_list()
-  def wrap(term)
-
+  @spec wrap(list | any) :: list
   def wrap(list) when is_list(list) do
     list
   end
@@ -495,96 +432,10 @@ defmodule List do
   """
   @spec zip([list]) :: [tuple]
   def zip([]), do: []
-
   def zip(list_of_lists) when is_list(list_of_lists) do
     do_zip(list_of_lists, [])
   end
 
-  @doc ~S"""
-  Checks if `list` is a charlist made only of printable ASCII characters.
-
-  Takes an optional `limit` as a second argument. `ascii_printable?/2` only
-  checks the printability of the list up to the `limit`.
-
-  A printable charlist in Elixir contains only the printable characters in the
-  standard seven-bit ASCII character encoding, which are characters ranging from
-  32 to 126 in decimal notation, plus the following control characters:
-
-    * `?\a` - Bell
-    * `?\b` - Backspace
-    * `?\t` - Horizontal tab
-    * `?\n` - Line feed
-    * `?\v` - Vertical tab
-    * `?\f` - Form feed
-    * `?\r` - Carriage return
-    * `?\e` - Escape
-
-  For more information read the [Character groups](https://en.wikipedia.org/wiki/ASCII#Character_groups)
-  section in the Wikipedia article of the [ASCII](https://en.wikipedia.org/wiki/ASCII) standard.
-
-  ## Examples
-
-      iex> List.ascii_printable?('abc')
-      true
-
-      iex> List.ascii_printable?('abc' ++ [0])
-      false
-
-      iex> List.ascii_printable?('abc' ++ [0], 2)
-      true
-
-  Improper lists are not printable, even if made only of ASCII characters:
-
-      iex> List.ascii_printable?('abc' ++ ?d)
-      false
-
-  """
-  @doc since: "1.6.0"
-  @spec ascii_printable?(list, 0) :: true
-  @spec ascii_printable?([], limit) :: true
-        when limit: :infinity | pos_integer
-  @spec ascii_printable?([...], limit) :: boolean
-        when limit: :infinity | pos_integer
-  def ascii_printable?(list, limit \\ :infinity)
-      when is_list(list) and (limit == :infinity or (is_integer(limit) and limit >= 0)) do
-    ascii_printable_guarded?(list, limit)
-  end
-
-  defp ascii_printable_guarded?(_, 0) do
-    true
-  end
-
-  defp ascii_printable_guarded?([char | rest], counter)
-       # 7..13 is the range '\a\b\t\n\v\f\r'. 32..126 are ASCII printables.
-       when is_integer(char) and
-              ((char >= 7 and char <= 13) or char == ?\e or (char >= 32 and char <= 126)) do
-    ascii_printable_guarded?(rest, decrement(counter))
-  end
-
-  defp ascii_printable_guarded?([], _counter), do: true
-  defp ascii_printable_guarded?(_, _counter), do: false
-
-  @compile {:inline, decrement: 1}
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter), do: counter - 1
-
-  @doc """
-  Returns `true` if `list` is an improper list. Otherwise returns `false`.
-
-  ## Examples
-
-      iex> List.improper?([1, 2 | 3])
-      true
-
-      iex> List.improper?([1, 2, 3])
-      false
-
-  """
-  @doc since: "1.8.0"
-  @spec improper?(maybe_improper_list) :: boolean
-  def improper?(list) when is_list(list) and length(list) >= 0, do: false
-  def improper?(list) when is_list(list), do: true
-
   @doc """
   Returns a list with `value` inserted at the specified `index`.
 
@@ -607,19 +458,11 @@ defmodule List do
 
   """
   @spec insert_at(list, integer, any) :: list
-  def insert_at(list, index, value) when is_list(list) and is_integer(index) do
-    case index do
-      -1 ->
-        list ++ [value]
-
-      _ when index < 0 ->
-        case length(list) + index + 1 do
-          index when index < 0 -> [value | list]
-          index -> do_insert_at(list, index, value)
-        end
-
-      _ ->
-        do_insert_at(list, index, value)
+  def insert_at(list, index, value) when is_integer(index) do
+    if index < 0 do
+      do_insert_at(list, length(list) + index + 1, value)
+    else
+      do_insert_at(list, index, value)
     end
   end
 
@@ -645,12 +488,9 @@ defmodule List do
 
   """
   @spec replace_at(list, integer, any) :: list
-  def replace_at(list, index, value) when is_list(list) and is_integer(index) do
+  def replace_at(list, index, value) when is_integer(index) do
     if index < 0 do
-      case length(list) + index do
-        index when index < 0 -> list
-        index -> do_replace_at(list, index, value)
-      end
+      do_replace_at(list, length(list) + index, value)
     else
       do_replace_at(list, index, value)
     end
@@ -678,12 +518,9 @@ defmodule List do
 
   """
   @spec update_at([elem], integer, (elem -> any)) :: list when elem: var
-  def update_at(list, index, fun) when is_list(list) and is_function(fun) and is_integer(index) do
+  def update_at(list, index, fun) when is_function(fun, 1) and is_integer(index) do
     if index < 0 do
-      case length(list) + index do
-        index when index < 0 -> list
-        index -> do_update_at(list, index, fun)
-      end
+      do_update_at(list, length(list) + index, fun)
     else
       do_update_at(list, index, fun)
     end
@@ -730,7 +567,6 @@ defmodule List do
       {3, [1, 2]}
 
   """
-  @doc since: "1.4.0"
   @spec pop_at(list, integer, any) :: {any, list}
   def pop_at(list, index, default \\ nil) when is_integer(index) do
     if index < 0 do
@@ -740,51 +576,18 @@ defmodule List do
     end
   end
 
-  @doc """
-  Returns `true` if `list` starts with the given `prefix` list; otherwise returns `false`.
-
-  If `prefix` is an empty list, it returns `true`.
-
-  ### Examples
-
-      iex> List.starts_with?([1, 2, 3], [1, 2])
-      true
-
-      iex> List.starts_with?([1, 2], [1, 2, 3])
-      false
-
-      iex> List.starts_with?([:alpha], [])
-      true
-
-      iex> List.starts_with?([], [:alpha])
-      false
-
-  """
-  @doc since: "1.5.0"
-  @spec starts_with?(nonempty_list, nonempty_list) :: boolean
-  @spec starts_with?(list, []) :: true
-  @spec starts_with?([], nonempty_list) :: false
-  def starts_with?(list, prefix)
-
-  def starts_with?([head | tail], [head | prefix_tail]), do: starts_with?(tail, prefix_tail)
-  def starts_with?(list, []) when is_list(list), do: true
-  def starts_with?(list, [_ | _]) when is_list(list), do: false
-
   @doc """
   Converts a charlist to an atom.
 
-  Elixir supports conversions from charlists which contains any Unicode
-  code point.
+  Currently Elixir does not support conversions from charlists
+  which contains Unicode codepoints greater than 0xFF.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> List.to_atom('Elixir')
-      :Elixir
-
-      iex> List.to_atom('🌢 Elixir')
-      :"🌢 Elixir"
+      iex> List.to_atom('elixir')
+      :elixir
 
   """
   @spec to_atom(charlist) :: atom
@@ -796,8 +599,8 @@ defmodule List do
   Converts a charlist to an existing atom. Raises an `ArgumentError`
   if the atom does not exist.
 
-  Elixir supports conversions from charlists which contains any Unicode
-  code point.
+  Currently Elixir does not support conversions from charlists
+  which contains Unicode codepoints greater than 0xFF.
 
   Inlined by the compiler.
 
@@ -807,10 +610,6 @@ defmodule List do
       iex> List.to_existing_atom('my_atom')
       :my_atom
 
-      iex> _ = :"🌢 Elixir"
-      iex> List.to_existing_atom('🌢 Elixir')
-      :"🌢 Elixir"
-
       iex> List.to_existing_atom('this_atom_will_never_exist')
       ** (ArgumentError) argument error
 
@@ -857,8 +656,6 @@ defmodule List do
 
   Inlined by the compiler.
 
-  The base needs to be between `2` and `36`.
-
   ## Examples
 
       iex> List.to_integer('3FF', 16)
@@ -887,18 +684,11 @@ defmodule List do
   end
 
   @doc """
-  Converts a list of integers representing code points, lists or
+  Converts a list of integers representing codepoints, lists or
   strings into a string.
 
-  To be converted to a string, a list must either be empty or only
-  contain the following elements:
-
-    * strings
-    * integers representing Unicode code points
-    * a list containing one of these three elements
-
   Notice that this function expects a list of integers representing
-  Unicode code points. If you have a list of bytes, you must instead use
+  UTF-8 codepoints. If you have a list of bytes, you must instead use
   the [`:binary` module](http://www.erlang.org/doc/man/binary.html).
 
   ## Examples
@@ -909,14 +699,8 @@ defmodule List do
       iex> List.to_string([0x0061, "bc"])
       "abc"
 
-      iex> List.to_string([0x0064, "ee", ['p']])
-      "deep"
-
-      iex> List.to_string([])
-      ""
-
   """
-  @spec to_string(:unicode.charlist()) :: String.t()
+  @spec to_string(:unicode.charlist) :: String.t
   def to_string(list) when is_list(list) do
     try do
       :unicode.characters_to_binary(list)
@@ -925,71 +709,18 @@ defmodule List do
         raise ArgumentError, """
         cannot convert the given list to a string.
 
-        To be converted to a string, a list must either be empty or only
-        contain the following elements:
+        To be converted to a string, a list must contain only:
 
           * strings
-          * integers representing Unicode code points
-          * a list containing one of these three elements
-
-        Please check the given list or call inspect/1 to get the list representation, got:
-
-        #{inspect(list)}
-        """
-    else
-      result when is_binary(result) ->
-        result
-
-      {:error, encoded, rest} ->
-        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
-
-      {:incomplete, encoded, rest} ->
-        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :incomplete
-    end
-  end
-
-  @doc """
-  Converts a list of integers representing Unicode code points, lists or
-  strings into a charlist.
-
-  Notice that this function expects a list of integers representing
-  Unicode code points. If you have a list of bytes, you must instead use
-  the [`:binary` module](http://www.erlang.org/doc/man/binary.html).
-
-  ## Examples
-
-      iex> List.to_charlist([0x00E6, 0x00DF])
-      'æß'
-
-      iex> List.to_charlist([0x0061, "bc"])
-      'abc'
-
-      iex> List.to_charlist([0x0064, "ee", ['p']])
-      'deep'
-
-  """
-  @doc since: "1.8.0"
-  @spec to_charlist(:unicode.charlist()) :: charlist()
-  def to_charlist(list) when is_list(list) do
-    try do
-      :unicode.characters_to_list(list)
-    rescue
-      ArgumentError ->
-        raise ArgumentError, """
-        cannot convert the given list to a charlist.
-
-        To be converted to a charlist, a list must contain only:
-
-          * strings
-          * integers representing Unicode code points
+          * integers representing Unicode codepoints
           * or a list containing one of these three elements
 
         Please check the given list or call inspect/1 to get the list representation, got:
 
-        #{inspect(list)}
+        #{inspect list}
         """
     else
-      result when is_list(result) ->
+      result when is_binary(result) ->
         result
 
       {:error, encoded, rest} ->
@@ -1013,142 +744,89 @@ defmodule List do
   corresponding key is `:del`), or left alone (if the corresponding key is
   `:eq`) in `list1` in order to be closer to `list2`.
 
-  See `myers_difference/3` if you want to handle nesting in the diff scripts.
-
   ## Examples
 
       iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
       [eq: [1], del: [4], eq: [2, 3], ins: [4]]
 
   """
-  @doc since: "1.4.0"
-  @spec myers_difference(list, list) :: [{:eq | :ins | :del, list}]
+  @spec myers_difference(list, list) :: [{:eq | :ins | :del, list}] | nil
   def myers_difference(list1, list2) when is_list(list1) and is_list(list2) do
-    myers_difference_with_diff_script(list1, list2, nil)
+    path = {0, 0, list1, list2, []}
+    find_script(0, length(list1) + length(list2), [path])
   end
 
-  @doc """
-  Returns a keyword list that represents an *edit script* with nested diffs.
-
-  This is an extension of `myers_difference/2` where a `diff_script` function
-  can be given in case it is desired to compute nested differences. The function
-  may return a list with the inner edit script or `nil` in case there is no
-  such script. The returned inner edit script will be under the `:diff` key.
-
-  ## Examples
-
-      iex> List.myers_difference(["a", "db", "c"], ["a", "bc"], &String.myers_difference/2)
-      [eq: ["a"], diff: [del: "d", eq: "b", ins: "c"], del: ["c"]]
-
-  """
-  @doc since: "1.8.0"
-  @spec myers_difference(list, list, (term, term -> script | nil)) :: script
-        when script: [{:eq | :ins | :del | :diff, list}]
-  def myers_difference(list1, list2, diff_script)
-      when is_list(list1) and is_list(list2) and is_function(diff_script) do
-    myers_difference_with_diff_script(list1, list2, diff_script)
+  defp find_script(envelope, max, _paths) when envelope > max do
+    nil
   end
 
-  defp myers_difference_with_diff_script(list1, list2, diff_script) do
-    path = {0, list1, list2, []}
-    find_script(0, length(list1) + length(list2), [path], diff_script)
-  end
-
-  defp find_script(envelope, max, paths, diff_script) do
-    case each_diagonal(-envelope, envelope, paths, [], diff_script) do
+  defp find_script(envelope, max, paths) do
+    case each_diagonal(-envelope, envelope, paths, []) do
       {:done, edits} -> compact_reverse(edits, [])
-      {:next, paths} -> find_script(envelope + 1, max, paths, diff_script)
+      {:next, paths} -> find_script(envelope + 1, max, paths)
     end
   end
 
   defp compact_reverse([], acc), do: acc
 
-  defp compact_reverse([{:diff, _} = fragment | rest], acc) do
-    compact_reverse(rest, [fragment | acc])
-  end
-
   defp compact_reverse([{kind, elem} | rest], [{kind, result} | acc]) do
     compact_reverse(rest, [{kind, [elem | result]} | acc])
   end
 
-  defp compact_reverse(rest, [{:eq, elem}, {:ins, elem}, {:eq, other} | acc]) do
-    compact_reverse(rest, [{:ins, elem}, {:eq, elem ++ other} | acc])
-  end
-
   defp compact_reverse([{kind, elem} | rest], acc) do
     compact_reverse(rest, [{kind, [elem]} | acc])
   end
 
-  defp each_diagonal(diag, limit, _paths, next_paths, _diff_script) when diag > limit do
-    {:next, :lists.reverse(next_paths)}
+  defp each_diagonal(diag, limit, _paths, next_paths) when diag > limit do
+    {:next, Enum.reverse(next_paths)}
   end
 
-  defp each_diagonal(diag, limit, paths, next_paths, diff_script) do
-    {path, rest} = proceed_path(diag, limit, paths, diff_script)
-
-    case follow_snake(path) do
-      {:cont, path} -> each_diagonal(diag + 2, limit, rest, [path | next_paths], diff_script)
-      {:done, edits} -> {:done, edits}
+  defp each_diagonal(diag, limit, paths, next_paths) do
+    {path, rest} = proceed_path(diag, limit, paths)
+    with {:cont, path} <- follow_snake(path) do
+      each_diagonal(diag + 2, limit, rest, [path | next_paths])
     end
   end
 
-  defp proceed_path(0, 0, [path], _diff_script), do: {path, []}
+  defp proceed_path(0, 0, [path]), do: {path, []}
 
-  defp proceed_path(diag, limit, [path | _] = paths, diff_script) when diag == -limit do
-    {move_down(path, diff_script), paths}
+  defp proceed_path(diag, limit, [path | _] = paths) when diag == -limit do
+    {move_down(path), paths}
   end
 
-  defp proceed_path(diag, limit, [path], diff_script) when diag == limit do
-    {move_right(path, diff_script), []}
+  defp proceed_path(diag, limit, [path]) when diag == limit do
+    {move_right(path), []}
   end
 
-  defp proceed_path(_diag, _limit, [path1, path2 | rest], diff_script) do
-    if elem(path1, 0) > elem(path2, 0) do
-      {move_right(path1, diff_script), [path2 | rest]}
+  defp proceed_path(_diag, _limit, [path1, path2 | rest]) do
+    if elem(path1, 1) > elem(path2, 1) do
+      {move_right(path1), [path2 | rest]}
     else
-      {move_down(path2, diff_script), [path2 | rest]}
+      {move_down(path2), [path2 | rest]}
     end
   end
 
-  defp move_right({y, [elem1 | rest1] = list1, [elem2 | rest2], edits}, diff_script)
-       when diff_script != nil do
-    if diff = diff_script.(elem1, elem2) do
-      {y + 1, rest1, rest2, [{:diff, diff} | edits]}
-    else
-      {y, list1, rest2, [{:ins, elem2} | edits]}
-    end
+  defp move_right({x, y, list1, [elem | rest], edits}) do
+    {x + 1, y, list1, rest, [{:ins, elem} | edits]}
   end
 
-  defp move_right({y, list1, [elem | rest], edits}, _diff_script) do
-    {y, list1, rest, [{:ins, elem} | edits]}
+  defp move_right({x, y, list1, [], edits}) do
+    {x + 1, y, list1, [], edits}
   end
 
-  defp move_right({y, list1, [], edits}, _diff_script) do
-    {y, list1, [], edits}
+  defp move_down({x, y, [elem | rest], list2, edits}) do
+    {x, y + 1, rest, list2, [{:del, elem} | edits]}
   end
 
-  defp move_down({y, [elem1 | rest1], [elem2 | rest2] = list2, edits}, diff_script)
-       when diff_script != nil do
-    if diff = diff_script.(elem1, elem2) do
-      {y + 1, rest1, rest2, [{:diff, diff} | edits]}
-    else
-      {y + 1, rest1, list2, [{:del, elem1} | edits]}
-    end
+  defp move_down({x, y, [], list2, edits}) do
+    {x, y + 1, [], list2, edits}
   end
 
-  defp move_down({y, [elem | rest], list2, edits}, _diff_script) do
-    {y + 1, rest, list2, [{:del, elem} | edits]}
+  defp follow_snake({x, y, [elem | rest1], [elem | rest2], edits}) do
+    follow_snake({x + 1, y + 1, rest1, rest2, [{:eq, elem} | edits]})
   end
 
-  defp move_down({y, [], list2, edits}, _diff_script) do
-    {y + 1, [], list2, edits}
-  end
-
-  defp follow_snake({y, [elem | rest1], [elem | rest2], edits}) do
-    follow_snake({y + 1, rest1, rest2, [{:eq, elem} | edits]})
-  end
-
-  defp follow_snake({_y, [], [], edits}) do
+  defp follow_snake({_x, _y, [], [], edits}) do
     {:done, edits}
   end
 
@@ -1164,6 +842,10 @@ defmodule List do
     []
   end
 
+  defp do_replace_at(list, index, _value) when index < 0 do
+    list
+  end
+
   defp do_replace_at([_old | rest], 0, value) do
     [value | rest]
   end
@@ -1178,7 +860,7 @@ defmodule List do
     [value]
   end
 
-  defp do_insert_at(list, 0, value) do
+  defp do_insert_at(list, index, value) when index <= 0 do
     [value | list]
   end
 
@@ -1192,6 +874,10 @@ defmodule List do
     [fun.(value) | list]
   end
 
+  defp do_update_at(list, index, _fun) when index < 0 do
+    list
+  end
+
   defp do_update_at([head | tail], index, fun) do
     [head | do_update_at(tail, index - 1, fun)]
   end
@@ -1206,6 +892,10 @@ defmodule List do
     {default, :lists.reverse(acc)}
   end
 
+  defp do_pop_at(list, index, default, []) when index < 0 do
+    {default, list}
+  end
+
   defp do_pop_at([head | tail], 0, _default, acc) do
     {head, :lists.reverse(acc, tail)}
   end
@@ -1218,11 +908,8 @@ defmodule List do
 
   defp do_zip(list, acc) do
     converter = fn x, acc -> do_zip_each(to_list(x), acc) end
-
     case :lists.mapfoldl(converter, [], list) do
-      {_, nil} ->
-        :lists.reverse(acc)
-
+      {_, nil} -> :lists.reverse(acc)
       {mlist, heads} ->
         do_zip(mlist, [to_tuple(:lists.reverse(heads)) | acc])
     end
@@ -1241,5 +928,5 @@ defmodule List do
   end
 
   defp to_list(tuple) when is_tuple(tuple), do: Tuple.to_list(tuple)
-  defp to_list(list) when is_list(list), do: list
+  defp to_list(list)  when is_list(list),   do: list
 end

lib/elixir/lib/list/chars.ex

@@ -1,31 +1,24 @@
 defprotocol List.Chars do
   @moduledoc ~S"""
-  The `List.Chars` protocol is responsible for
-  converting a structure to a charlist (only if applicable).
-
+  The List.Chars protocol is responsible for
+  converting a structure to a list (only if applicable).
   The only function required to be implemented is
-  `to_charlist/1` which does the conversion.
+  `to_charlist` which does the conversion.
 
   The `to_charlist/1` function automatically imported
   by `Kernel` invokes this protocol.
   """
 
-  @doc """
-  Converts `term` to a charlist.
-  """
-  @spec to_charlist(t) :: charlist
   def to_charlist(term)
 
+  # TODO: Deprecate by v1.5
   @doc false
-  @deprecated "Use List.Chars.to_charlist/1 instead"
   Kernel.def to_char_list(term) do
     __MODULE__.to_charlist(term)
   end
 end
 
 defimpl List.Chars, for: Atom do
-  def to_charlist(nil), do: ''
-
   def to_charlist(atom), do: Atom.to_charlist(atom)
 end
 
@@ -39,9 +32,9 @@ defimpl List.Chars, for: BitString do
 
   def to_charlist(term) do
     raise Protocol.UndefinedError,
-      protocol: @protocol,
-      value: term,
-      description: "cannot convert a bitstring to a charlist"
+             protocol: @protocol,
+                value: term,
+          description: "cannot convert a bitstring to a charlist"
   end
 end
 

lib/elixir/lib/macro/env.ex

@@ -21,169 +21,91 @@ defmodule Macro.Env do
 
   It contains the following fields:
 
-    * `aliases` -  a list of two-element tuples, where the first
-      element is the aliased name and the second one the actual name
-    * `context` - the context of the environment; it can be `nil`
-      (default context), `:guard` (inside a guard) or `:match` (inside a match)
-    * `context_modules` - a list of modules defined in the current context
+    * `module` - the current module name
     * `file` - the current file name as a binary
+    * `line` - the current line as an integer
     * `function` - a tuple as `{atom, integer}`, where the first
       element is the function name and the second its arity; returns
       `nil` if not inside a function
-    * `functions` - a list of functions imported from each module
-    * `line` - the current line as an integer
-    * `macro_aliases` - a list of aliases defined inside the current macro
-    * `macros` - a list of macros imported from each module
-    * `module` - the current module name
+    * `context` - the context of the environment; it can be `nil`
+      (default context), inside a guard or inside a match
+    * `aliases` -  a list of two-element tuples, where the first
+      element is the aliased name and the second one the actual name
     * `requires` - the list of required modules
-
-  The following fields are private to Elixir's macro expansion mechanism and
-  must not be accessed directly:
-
-    * `contextual_vars`
-    * `current_vars`
-    * `lexical_tracker`
-    * `prematch_vars`
-    * `tracers`
-    * `unused_vars`
-
-  The following fields are deprecated and must not be accessed or relied on:
-
+    * `functions` - a list of functions imported from each module
+    * `macros` - a list of macros imported from each module
+    * `macro_aliases` - a list of aliases defined inside the current macro
+    * `context_modules` - a list of modules defined in the current context
     * `vars` - a list keeping all defined variables as `{var, context}`
-
+    * `export_vars` - a list keeping all variables to be exported in a
+      construct (may be `nil`)
+    * `lexical_tracker` - PID of the lexical tracker which is responsible for
+      keeping user info
   """
 
-  @type aliases :: [{module, module}]
-  @type context :: :match | :guard | nil
-  @type context_modules :: [module]
-  @type file :: binary
-  @type functions :: [{module, [name_arity]}]
-  @type lexical_tracker :: pid | nil
-  @type line :: non_neg_integer
-  @type macro_aliases :: [{module, {term, module}}]
-  @type macros :: [{module, [name_arity]}]
   @type name_arity :: {atom, arity}
+  @type file :: binary
+  @type line :: non_neg_integer
+  @type aliases :: [{module, module}]
+  @type macro_aliases :: [{module, {integer, module}}]
+  @type context :: :match | :guard | nil
   @type requires :: [module]
-  @type variable :: {atom, atom | term}
+  @type functions :: [{module, [name_arity]}]
+  @type macros :: [{module, [name_arity]}]
+  @type context_modules :: [module]
+  @type vars :: [{atom, atom | non_neg_integer}]
+  @type export_vars :: vars | nil
+  @type lexical_tracker :: pid
+  @type local :: atom | nil
 
-  @typep contextual_vars :: [atom]
-  @typep current_vars ::
-           {%{optional(variable) => {var_version, var_type}},
-            %{optional(variable) => {var_version, var_type}} | false}
-  @typep unused_vars ::
-           {%{optional({atom, var_version}) => non_neg_integer | false}, non_neg_integer}
-  @typep prematch_vars ::
-           {%{optional(variable) => {var_version, var_type}}, non_neg_integer}
-           | :warn
-           | :raise
-           | :pin
-           | :apply
-  @typep tracers :: [module]
-  @typep var_type :: :term
-  @typep var_version :: non_neg_integer
-  @typep vars :: [variable]
+  @type t :: %{__struct__: __MODULE__,
+               module: atom,
+               file: file,
+               line: line,
+               function: name_arity | nil,
+               context: context,
+               requires: requires,
+               aliases: aliases,
+               functions: functions,
+               macros: macros,
+               macro_aliases: aliases,
+               context_modules: context_modules,
+               vars: vars,
+               export_vars: export_vars,
+               lexical_tracker: lexical_tracker}
 
-  @type t :: %{
-          __struct__: __MODULE__,
-          aliases: aliases,
-          context: context,
-          context_modules: context_modules,
-          contextual_vars: contextual_vars,
-          current_vars: current_vars,
-          file: file,
-          function: name_arity | nil,
-          functions: functions,
-          lexical_tracker: lexical_tracker,
-          line: line,
-          macro_aliases: macro_aliases,
-          macros: macros,
-          module: atom,
-          prematch_vars: prematch_vars,
-          unused_vars: unused_vars,
-          requires: requires,
-          tracers: tracers,
-          vars: vars
-        }
-
-  # TODO: Remove :vars field on v2.0
   def __struct__ do
-    %{
-      __struct__: __MODULE__,
-      aliases: [],
-      context: nil,
-      context_modules: [],
-      contextual_vars: [],
-      current_vars: {%{}, %{}},
-      file: "nofile",
-      function: nil,
-      functions: [],
-      lexical_tracker: nil,
-      line: 0,
-      macro_aliases: [],
-      macros: [],
+    %{__struct__: __MODULE__,
       module: nil,
-      prematch_vars: :warn,
+      file: "nofile",
+      line: 0,
+      function: nil,
+      context: nil,
       requires: [],
-      tracers: [],
-      unused_vars: {%{}, 0},
-      vars: []
-    }
+      aliases: [],
+      functions: [],
+      macros: [],
+      macro_aliases: [],
+      context_modules: [],
+      vars: [],
+      export_vars: nil,
+      lexical_tracker: nil}
   end
 
   def __struct__(kv) do
-    Enum.reduce(kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end)
-  end
-
-  @doc """
-  Returns a list of variables in the current environment.
-
-  Each variable is identified by a tuple of two elements,
-  where the first element is the variable name as an atom
-  and the second element is its context, which may be an
-  atom or an integer.
-  """
-  @doc since: "1.7.0"
-  @spec vars(t) :: [variable]
-  def vars(env)
-
-  def vars(%{__struct__: Macro.Env, current_vars: {read, _}}) do
-    Map.keys(read)
-  end
-
-  @doc """
-  Checks if a variable belongs to the environment.
-  """
-  @doc since: "1.7.0"
-  @spec has_var?(t, variable) :: boolean()
-  def has_var?(env, var)
-
-  def has_var?(%{__struct__: Macro.Env, current_vars: {read, _}}, var) do
-    Map.has_key?(read, var)
+    Enum.reduce kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end
   end
 
   @doc """
   Returns a keyword list containing the file and line
   information as keys.
   """
-  @spec location(t) :: keyword
+  @spec location(t) :: Keyword.t
   def location(env)
-
   def location(%{__struct__: Macro.Env, file: file, line: line}) do
     [file: file, line: line]
   end
 
-  @doc """
-  Returns a `Macro.Env` in the match context.
-  """
-  @spec to_match(t) :: t
-  def to_match(%{__struct__: Macro.Env, context: :match} = env) do
-    env
-  end
-
-  def to_match(%{__struct__: Macro.Env, current_vars: {read, _}, unused_vars: {_, counter}} = env) do
-    %{env | context: :match, prematch_vars: {read, counter}}
-  end
-
   @doc """
   Returns whether the compilation environment is currently
   inside a guard.
@@ -208,10 +130,8 @@ defmodule Macro.Env do
     cond do
       is_nil(env.module) ->
         [{:elixir_compiler, :__FILE__, 1, relative_location(env)}]
-
       is_nil(env.function) ->
         [{env.module, :__MODULE__, 0, relative_location(env)}]
-
       true ->
         {name, arity} = env.function
         [{env.module, name, arity, relative_location(env)}]
@@ -219,6 +139,6 @@ defmodule Macro.Env do
   end
 
   defp relative_location(env) do
-    [file: String.to_charlist(Path.relative_to_cwd(env.file)), line: env.line]
+    [file: Path.relative_to_cwd(env.file), line: env.line]
   end
 end

lib/elixir/lib/map.ex

@@ -1,9 +1,9 @@
 defmodule Map do
   @moduledoc """
-  Maps are the "go to" key-value data structure in Elixir.
+  A set of functions for working with maps.
 
-  Maps can be created with the `%{}` syntax, and key-value pairs can be
-  expressed as `key => value`:
+  Maps are the "go to" key-value data structure in Elixir. Maps can be created
+  with the `%{}` syntax, and key-value pairs can be expressed as `key => value`:
 
       iex> %{}
       %{}
@@ -14,8 +14,8 @@ defmodule Map do
   in the example above has a different order than the map that was created).
 
   Maps do not impose any restriction on the key type: anything can be a key in a
-  map. As a key-value structure, maps do not allow duplicated keys. Keys are
-  compared using the exact-equality operator (`===/2`). If colliding keys are defined
+  map. As a key-value structure, maps do not allow duplicated keys; keys are
+  compared using the exact-equality operator (`===`). If colliding keys are defined
   in a map literal, the last one prevails.
 
   When the key in a key-value pair is an atom, the `key: value` shorthand syntax
@@ -26,8 +26,8 @@ defmodule Map do
       %{:a => 1, :b => 2, "hello" => "world"}
 
   Keys in maps can be accessed through some of the functions in this module
-  (such as `Map.get/3` or `Map.fetch/2`) or through the `map[]` syntax provided
-  by the `Access` module:
+  (such as `Map.get/3` or `Map.fetch/2`) or through the `[]` syntax provided by
+  the `Access` module:
 
       iex> map = %{a: 1, b: 2}
       iex> Map.fetch(map, :a)
@@ -37,9 +37,10 @@ defmodule Map do
       iex> map["non_existing_key"]
       nil
 
-  For accessing atom keys, one may also `map.key`. Note that while `map[key]` will
-  return `nil` if `map` doesn't contain `key`, `map.key` will raise if `map` doesn't
-  contain the key `:key`.
+  The alternative access syntax `map.key` is provided alongside `[]` when the
+  map has a `:key` key; note that while `map[key]` will return `nil` if `map`
+  doesn't contain the key `key`, `map.key` will raise if `map` doesn't contain
+  the key `:key`.
 
       iex> map = %{foo: "bar", baz: "bong"}
       iex> map.foo
@@ -47,13 +48,7 @@ defmodule Map do
       iex> map.non_existing_key
       ** (KeyError) key :non_existing_key not found in: %{baz: "bong", foo: "bar"}
 
-  The two syntaxes for accessing keys reveal the dual nature of maps. The `map[key]`
-  syntax is used for dynamically created maps that may have any key, of any type.
-  `map.key` is used with maps that hold a predetermined set of atoms keys, which are
-  expected to always be present. Structs, defined via `defstruct/1`, are one example
-  of such "static maps", where the keys can also be checked during compile time.
-
-  Maps can be pattern matched on. When a map is on the left-hand side of a
+  Maps can be pattern matched on; when a map is on the left-hand side of a
   pattern match, it will match if the map on the right-hand side contains the
   keys on the left-hand side and their values match the ones on the left-hand
   side. This means that an empty map matches every map.
@@ -85,30 +80,25 @@ defmodule Map do
       iex> %{map | three: 3}
       ** (KeyError) key :three not found
 
-  The functions in this module that need to find a specific key work in logarithmic time.
-  This means that the time it takes to find keys grows as the map grows, but it's not
-  directly proportional to the map size. In comparison to finding an element in a list,
-  it performs better because lists have a linear time complexity. Some functions,
-  such as `keys/1` and `values/1`, run in linear time because they need to get to every
-  element in the map.
+  ## Modules to work with maps
 
-  Maps also implement the `Enumerable` protocol, so many functions to work with maps
-  are found in the `Enum` module. Additionally, the following functions for maps are
-  found in `Kernel`:
-
-    * `map_size/1`
+  This module aims to provide functions that perform operations specific to maps
+  (like accessing keys, updating values, and so on). For traversing maps as
+  collections, developers should use the `Enum` module that works across a
+  variety of data types.
 
+  The `Kernel` module also provides a few functions to work with maps: for
+  example, `Kernel.map_size/1` to know the number of key-value pairs in a map or
+  `Kernel.is_map/1` to know if a term is a map.
   """
 
   @type key :: any
   @type value :: any
-  @compile {:inline, fetch: 2, fetch!: 2, get: 2, put: 3, delete: 2, has_key?: 2, replace!: 3}
+  @compile {:inline, fetch: 2, put: 3, delete: 2, has_key?: 2}
 
   @doc """
   Returns all keys from `map`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.keys(%{a: 1, b: 2})
@@ -121,8 +111,6 @@ defmodule Map do
   @doc """
   Returns all values from `map`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.values(%{a: 1, b: 2})
@@ -138,8 +126,6 @@ defmodule Map do
   Each key-value pair in the map is converted to a two-element tuple `{key,
   value}` in the resulting list.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.to_list(%{a: 1})
@@ -156,7 +142,7 @@ defmodule Map do
 
   ## Examples
 
-      iex> Map.new()
+      iex> Map.new
       %{}
 
   """
@@ -172,21 +158,20 @@ defmodule Map do
 
       iex> Map.new([{:b, 1}, {:a, 2}])
       %{a: 2, b: 1}
-      iex> Map.new(a: 1, a: 2, a: 3)
+      iex> Map.new([a: 1, a: 2, a: 3])
       %{a: 3}
 
   """
-  @spec new(Enumerable.t()) :: map
+  @spec new(Enumerable.t) :: map
   def new(enumerable)
-  def new(list) when is_list(list), do: :maps.from_list(list)
-  def new(%_{} = struct), do: new_from_enum(struct)
+  def new(%{__struct__: _} = struct), do: new_from_enum(struct)
   def new(%{} = map), do: map
   def new(enum), do: new_from_enum(enum)
 
   defp new_from_enum(enumerable) do
     enumerable
-    |> Enum.to_list()
-    |> :maps.from_list()
+    |> Enum.to_list
+    |> :maps.from_list
   end
 
   @doc """
@@ -200,28 +185,26 @@ defmodule Map do
       %{a: :a, b: :b}
 
   """
-  @spec new(Enumerable.t(), (term -> {key, value})) :: map
+  @spec new(Enumerable.t, (term -> {key, value})) :: map
   def new(enumerable, transform) when is_function(transform, 1) do
     enumerable
-    |> Enum.to_list()
+    |> Enum.to_list
     |> new_transform(transform, [])
   end
 
   defp new_transform([], _fun, acc) do
     acc
-    |> :lists.reverse()
-    |> :maps.from_list()
+    |> :lists.reverse
+    |> :maps.from_list
   end
 
-  defp new_transform([element | rest], fun, acc) do
-    new_transform(rest, fun, [fun.(element) | acc])
+  defp new_transform([item | rest], fun, acc) do
+    new_transform(rest, fun, [fun.(item) | acc])
   end
 
   @doc """
   Returns whether the given `key` exists in the given `map`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.has_key?(%{a: 1}, :a)
@@ -239,8 +222,6 @@ defmodule Map do
   If `map` contains the given `key` with value `value`, then `{:ok, value}` is
   returned. If `map` doesn't contain `key`, `:error` is returned.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.fetch(%{a: 1}, :a)
@@ -259,17 +240,20 @@ defmodule Map do
   If `map` contains the given `key`, the corresponding value is returned. If
   `map` doesn't contain `key`, a `KeyError` exception is raised.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.fetch!(%{a: 1}, :a)
       1
+      iex> Map.fetch!(%{a: 1}, :b)
+      ** (KeyError) key :b not found in: %{a: 1}
 
   """
-  @spec fetch!(map, key) :: value
+  @spec fetch!(map, key) :: value | no_return
   def fetch!(map, key) do
-    :maps.get(key, map)
+    case fetch(map, key) do
+      {:ok, value} -> value
+      :error -> raise KeyError, key: key, term: map
+    end
   end
 
   @doc """
@@ -279,70 +263,26 @@ defmodule Map do
   ## Examples
 
       iex> Map.put_new(%{a: 1}, :b, 2)
-      %{a: 1, b: 2}
+      %{b: 2, a: 1}
       iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
       %{a: 1, b: 2}
 
   """
   @spec put_new(map, key, value) :: map
   def put_new(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        map
-
-      %{} ->
-        put(map, key, value)
-
-      other ->
-        :erlang.error({:badmap, other})
+    case has_key?(map, key) do
+      true  -> map
+      false -> put(map, key, value)
     end
   end
 
-  @doc false
-  @deprecated "Use Map.fetch/2 + Map.put/3 instead"
-  def replace(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        put(map, key, value)
-
-      %{} ->
-        map
-
-      other ->
-        :erlang.error({:badmap, other})
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in `map`.
-
-  If `key` is not present in `map`, a `KeyError` exception is raised.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-
-      iex> Map.replace!(%{a: 1}, :b, 2)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  """
-  @doc since: "1.5.0"
-  @spec replace!(map, key, value) :: map
-  def replace!(map, key, value) do
-    :maps.update(key, value, map)
-  end
-
   @doc """
   Evaluates `fun` and puts the result under `key`
   in `map` unless `key` is already present.
 
   This function is useful in case you want to compute the value to put under
-  `key` only if `key` is not already present, as for example, when the value is expensive to
-  calculate or generally difficult to setup and teardown again.
+  `key` only if `key` is not already present (e.g., the value is expensive to
+  calculate or generally difficult to setup and teardown again).
 
   ## Examples
 
@@ -359,15 +299,9 @@ defmodule Map do
   """
   @spec put_new_lazy(map, key, (() -> value)) :: map
   def put_new_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => _value} ->
-        map
-
-      %{} ->
-        put(map, key, fun.())
-
-      other ->
-        :erlang.error({:badmap, other})
+    case has_key?(map, key) do
+      true  -> map
+      false -> put(map, key, fun.())
     end
   end
 
@@ -383,47 +317,34 @@ defmodule Map do
       %{a: 1, c: 3}
 
   """
-  @spec take(map, [key]) :: map
+  @spec take(map, Enumerable.t) :: map
   def take(map, keys)
 
-  def take(map, keys) when is_map(map) and is_list(keys) do
-    take(keys, map, _acc = [])
-  end
-
   def take(map, keys) when is_map(map) do
-    IO.warn(
-      "Map.take/2 with an Enumerable of keys that is not a list is deprecated. " <>
-        " Use a list of keys instead."
-    )
-
-    take(map, Enum.to_list(keys))
+    keys
+    |> Enum.to_list
+    |> do_take(map, [])
   end
 
   def take(non_map, _keys) do
     :erlang.error({:badmap, non_map})
   end
 
-  defp take([], _map, acc) do
-    :maps.from_list(acc)
-  end
-
-  defp take([key | rest], map, acc) do
-    acc =
-      case map do
-        %{^key => value} -> [{key, value} | acc]
-        %{} -> acc
-      end
-
-    take(rest, map, acc)
+  defp do_take([], _map, acc), do: :maps.from_list(acc)
+  defp do_take([key | rest], map, acc) do
+    acc = case fetch(map, key) do
+      {:ok, value} -> [{key, value} | acc]
+      :error -> acc
+    end
+    do_take(rest, map, acc)
   end
 
   @doc """
   Gets the value for a specific `key` in `map`.
 
   If `key` is present in `map` with value `value`, then `value` is
-  returned. Otherwise, `default` is returned.
-
-  If `default` is not provided, `nil` is used.
+  returned. Otherwise, `default` is returned (which is `nil` unless
+  specified otherwise).
 
   ## Examples
 
@@ -437,17 +358,12 @@ defmodule Map do
       3
 
   """
+  @spec get(map, key) :: value
   @spec get(map, key, value) :: value
   def get(map, key, default \\ nil) do
-    case map do
-      %{^key => value} ->
-        value
-
-      %{} ->
-        default
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, default])
+    case fetch(map, key) do
+      {:ok, value} -> value
+      :error -> default
     end
   end
 
@@ -475,23 +391,15 @@ defmodule Map do
   """
   @spec get_lazy(map, key, (() -> value)) :: value
   def get_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => value} ->
-        value
-
-      %{} ->
-        fun.()
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, fun])
+    case fetch(map, key) do
+      {:ok, value} -> value
+      :error -> fun.()
     end
   end
 
   @doc """
   Puts the given `value` under `key` in `map`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.put(%{a: 1}, :b, 2)
@@ -510,8 +418,6 @@ defmodule Map do
 
   If the `key` does not exist, returns `map` unchanged.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.delete(%{a: 1, b: 2}, :a)
@@ -534,8 +440,6 @@ defmodule Map do
   side into the struct, even if the key is not part of the struct. Instead,
   use `Kernel.struct/2`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
@@ -546,12 +450,12 @@ defmodule Map do
   defdelegate merge(map1, map2), to: :maps
 
   @doc """
-  Merges two maps into one, resolving conflicts through the given `fun`.
+  Merges two maps into one, resolving conflicts through the given `callback`.
 
   All keys in `map2` will be added to `map1`. The given function will be invoked
   when there are duplicate keys; its arguments are `key` (the duplicate key),
   `value1` (the value of `key` in `map1`), and `value2` (the value of `key` in
-  `map2`). The value returned by `fun` is used as the value under `key` in
+  `map2`). The value returned by `callback` is used as the value under `key` in
   the resulting map.
 
   ## Examples
@@ -563,20 +467,10 @@ defmodule Map do
 
   """
   @spec merge(map, map, (key, value, value -> value)) :: map
-  def merge(map1, map2, fun) when is_function(fun, 3) do
-    if map_size(map1) > map_size(map2) do
-      folder = fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> fun.(key, val1, val2) end)
-      end
-
-      :maps.fold(folder, map1, map2)
-    else
-      folder = fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> fun.(key, val2, val1) end)
-      end
-
-      :maps.fold(folder, map2, map1)
-    end
+  def merge(map1, map2, callback) when is_function(callback, 3) do
+    :maps.fold fn k, v2, acc ->
+      update(acc, k, v2, fn(v1) -> callback.(k, v1, v2) end)
+    end, map1, map2
   end
 
   @doc """
@@ -584,8 +478,7 @@ defmodule Map do
 
   If `key` is present in `map` with value `value`, `fun` is invoked with
   argument `value` and its result is used as the new value of `key`. If `key` is
-  not present in `map`, `initial` is inserted as the value of `key`. The initial
-  value will not be passed through the update function.
+  not present in `map`, `initial` is inserted as the value of `key`.
 
   ## Examples
 
@@ -597,15 +490,11 @@ defmodule Map do
   """
   @spec update(map, key, value, (value -> value)) :: map
   def update(map, key, initial, fun) when is_function(fun, 1) do
-    case map do
-      %{^key => value} ->
+    case fetch(map, key) do
+      {:ok, value} ->
         put(map, key, fun.(value))
-
-      %{} ->
+      :error ->
         put(map, key, initial)
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, initial, fun])
     end
   end
 
@@ -628,34 +517,9 @@ defmodule Map do
   """
   @spec pop(map, key, value) :: {value, map}
   def pop(map, key, default \\ nil) do
-    case :maps.take(key, map) do
-      {_, _} = tuple -> tuple
-      :error -> {default, map}
-    end
-  end
-
-  @doc """
-  Returns and removes the value associated with `key` in `map` or raises
-  if `key` is not present.
-
-  Behaves the same as `pop/3` but raises if `key` is not present in `map`.
-
-  ## Examples
-
-      iex> Map.pop!(%{a: 1}, :a)
-      {1, %{}}
-      iex> Map.pop!(%{a: 1, b: 2}, :a)
-      {1, %{b: 2}}
-      iex> Map.pop!(%{a: 1}, :b)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  """
-  @doc since: "1.10.0"
-  @spec pop!(map, key) :: {value, map}
-  def pop!(map, key) do
-    case :maps.take(key, map) do
-      {_, _} = tuple -> tuple
-      :error -> raise KeyError, key: key, term: map
+    case map do
+      %{^key => value} -> {value, delete(map, key)}
+      %{} -> {default, map}
     end
   end
 
@@ -685,8 +549,8 @@ defmodule Map do
   """
   @spec pop_lazy(map, key, (() -> value)) :: {value, map}
   def pop_lazy(map, key, fun) when is_function(fun, 0) do
-    case :maps.take(key, map) do
-      {_, _} = tuple -> tuple
+    case fetch(map, key) do
+      {:ok, value} -> {value, delete(map, key)}
       :error -> {fun.(), map}
     end
   end
@@ -702,34 +566,26 @@ defmodule Map do
       %{a: 1, c: 3}
 
   """
-  @spec drop(map, [key]) :: map
+  @spec drop(map, Enumerable.t) :: map
   def drop(map, keys)
 
-  def drop(map, keys) when is_map(map) and is_list(keys) do
-    drop_keys(keys, map)
-  end
-
   def drop(map, keys) when is_map(map) do
-    IO.warn(
-      "Map.drop/2 with an Enumerable of keys that is not a list is deprecated. " <>
-        " Use a list of keys instead."
-    )
-
-    drop(map, Enum.to_list(keys))
+    keys
+    |> Enum.to_list
+    |> drop_list(map)
   end
 
-  def drop(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
+  def drop(non_map, _keys) do
+    :erlang.error({:badmap, non_map})
   end
 
-  defp drop_keys([], acc), do: acc
-
-  defp drop_keys([key | rest], acc) do
-    drop_keys(rest, delete(acc, key))
+  defp drop_list([], acc), do: acc
+  defp drop_list([key | rest], acc) do
+    drop_list(rest, delete(acc, key))
   end
 
   @doc """
-  Takes all entries corresponding to the given `keys` in `map` and extracts
+  Takes all entries corresponding to the given `keys` in `maps` and extracts
   them into a separate map.
 
   Returns a tuple with the new map and the old map with removed keys.
@@ -742,37 +598,28 @@ defmodule Map do
       {%{a: 1, c: 3}, %{b: 2}}
 
   """
-  @spec split(map, [key]) :: {map, map}
+  @spec split(map, Enumerable.t) :: {map, map}
   def split(map, keys)
 
-  def split(map, keys) when is_map(map) and is_list(keys) do
-    split(keys, [], map)
-  end
-
   def split(map, keys) when is_map(map) do
-    IO.warn(
-      "Map.split/2 with an Enumerable of keys that is not a list is deprecated. " <>
-        " Use a list of keys instead."
-    )
-
-    split(map, Enum.to_list(keys))
+    keys
+    |> Enum.to_list
+    |> do_split([], map)
   end
 
-  def split(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
+  def split(non_map, _keys) do
+    :erlang.error({:badmap, non_map})
   end
 
-  defp split([], included, excluded) do
-    {:maps.from_list(included), excluded}
+  defp do_split([], inc, exc) do
+    {:maps.from_list(inc), exc}
   end
-
-  defp split([key | rest], included, excluded) do
-    case excluded do
-      %{^key => value} ->
-        split(rest, [{key, value} | included], delete(excluded, key))
-
-      _other ->
-        split(rest, included, excluded)
+  defp do_split([key | rest], inc, exc) do
+    case fetch(exc, key) do
+      {:ok, value} ->
+        do_split(rest, [{key, value} | inc], delete(exc, key))
+      :error ->
+        do_split(rest, inc, exc)
     end
   end
 
@@ -792,12 +639,18 @@ defmodule Map do
       ** (KeyError) key :b not found in: %{a: 1}
 
   """
-  @spec update!(map, key, (value -> value)) :: map
-  def update!(map, key, fun) when is_function(fun, 1) do
-    value = fetch!(map, key)
-    put(map, key, fun.(value))
+  @spec update!(map, key, (value -> value)) :: map | no_return
+  def update!(%{} = map, key, fun) when is_function(fun, 1) do
+    case fetch(map, key) do
+      {:ok, value} ->
+        put(map, key, fun.(value))
+      :error ->
+        raise KeyError, term: map, key: key
+    end
   end
 
+  def update!(map, _key, _fun), do: :erlang.error({:badmap, map})
+
   @doc """
   Gets the value from `key` and updates it, all in one pass.
 
@@ -806,7 +659,7 @@ defmodule Map do
   (the retrieved value, which can be operated on before being returned) and the
   new value to be stored under `key` in the resulting new map. `fun` may also
   return `:pop`, which means the current value shall be removed from `map` and
-  returned (making this function behave like `Map.pop(map, key)`).
+  returned (making this function behave like `Map.pop(map, key)`.
 
   The returned value is a tuple with the "get" value returned by
   `fun` and a new map with the updated value under `key`.
@@ -831,21 +684,25 @@ defmodule Map do
 
   """
   @spec get_and_update(map, key, (value -> {get, value} | :pop)) :: {get, map} when get: term
-  def get_and_update(map, key, fun) when is_function(fun, 1) do
-    current = get(map, key)
+  def get_and_update(%{} = map, key, fun) when is_function(fun, 1) do
+    current =
+      case :maps.find(key, map) do
+        {:ok, value} -> value
+        :error -> nil
+      end
 
     case fun.(current) do
       {get, update} ->
-        {get, put(map, key, update)}
-
+        {get, :maps.put(key, update, map)}
       :pop ->
-        {current, delete(map, key)}
-
+        {current, :maps.remove(key, map)}
       other ->
         raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
     end
   end
 
+  def get_and_update(map, _key, _fun), do: :erlang.error({:badmap, map})
+
   @doc """
   Gets the value from `key` and updates it. Raises if there is no `key`.
 
@@ -870,23 +727,25 @@ defmodule Map do
       {1, %{}}
 
   """
-  @spec get_and_update!(map, key, (value -> {get, value} | :pop)) :: {get, map}
-        when get: term
-  def get_and_update!(map, key, fun) when is_function(fun, 1) do
-    value = fetch!(map, key)
-
-    case fun.(value) do
-      {get, update} ->
-        {get, put(map, key, update)}
-
-      :pop ->
-        {value, delete(map, key)}
-
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+  @spec get_and_update!(map, key, (value -> {get, value})) :: {get, map} | no_return when get: term
+  def get_and_update!(%{} = map, key, fun) when is_function(fun, 1) do
+    case :maps.find(key, map) do
+      {:ok, value} ->
+        case fun.(value) do
+          {get, update} ->
+            {get, :maps.put(key, update, map)}
+          :pop ->
+            {value, :maps.remove(key, map)}
+          other ->
+            raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+        end
+      :error ->
+        raise KeyError, term: map, key: key
     end
   end
 
+  def get_and_update!(map, _key, _fun), do: :erlang.error({:badmap, map})
+
   @doc """
   Converts a `struct` to map.
 
@@ -909,11 +768,11 @@ defmodule Map do
   """
   @spec from_struct(atom | struct) :: map
   def from_struct(struct) when is_atom(struct) do
-    delete(struct.__struct__(), :__struct__)
+    :maps.remove(:__struct__, struct.__struct__)
   end
 
-  def from_struct(%_{} = struct) do
-    delete(struct, :__struct__)
+  def from_struct(%{__struct__: _} = struct) do
+    :maps.remove(:__struct__, struct)
   end
 
   @doc """
@@ -931,15 +790,12 @@ defmodule Map do
 
   """
   @spec equal?(map, map) :: boolean
-  def equal?(map1, map2)
-
   def equal?(%{} = map1, %{} = map2), do: map1 === map2
-  def equal?(%{} = map1, map2), do: :erlang.error({:badmap, map2}, [map1, map2])
-  def equal?(term, other), do: :erlang.error({:badmap, term}, [term, other])
 
   @doc false
-  @deprecated "Use Kernel.map_size/1 instead"
+  # TODO: Remove on 2.0
   def size(map) do
+    IO.warn "Map.size/1 is deprecated, please use Kernel.map_size/1"
     map_size(map)
   end
 end

lib/elixir/lib/map_set.ex

@@ -2,33 +2,21 @@ defmodule MapSet do
   @moduledoc """
   Functions that work on sets.
 
-  A set is a data structure that can contain unique elements of any kind,
-  without any particular order. `MapSet` is the "go to" set data structure in Elixir.
+  `MapSet` is the "go to" set data structure in Elixir. A set can be constructed
+  using `MapSet.new/0`:
 
-  A set can be constructed using `MapSet.new/0`:
-
-      iex> MapSet.new()
+      iex> MapSet.new
       #MapSet<[]>
 
-  Elements in a set don't have to be of the same type and they can be
-  populated from an [enumerable](`t:Enumerable.t/0`) using `MapSet.new/1`:
-
-      iex> MapSet.new([1, :two, {"three"}])
-      #MapSet<[1, :two, {"three"}]>
-
-  Elements can be inserted using `MapSet.put/2`:
-
-      iex> MapSet.new([2]) |> MapSet.put(4) |> MapSet.put(0)
-      #MapSet<[0, 2, 4]>
-
-  By definition, sets can't contain duplicate elements: when
+  A set can contain any kind of elements and elements in a set don't have to be
+  of the same type. By definition, sets can't contain duplicate elements: when
   inserting an element in a set where it's already present, the insertion is
   simply a no-op.
 
-      iex> map_set = MapSet.new()
-      iex> MapSet.put(map_set, "foo")
+      iex> set = MapSet.new
+      iex> MapSet.put(set, "foo")
       #MapSet<["foo"]>
-      iex> map_set |> MapSet.put("foo") |> MapSet.put("foo")
+      iex> set |> MapSet.put("foo") |> MapSet.put("foo")
       #MapSet<["foo"]>
 
   A `MapSet` is represented internally using the `%MapSet{}` struct. This struct
@@ -40,32 +28,23 @@ defmodule MapSet do
   Note that, however, the struct fields are private and must not be accessed
   directly; use the functions in this module to perform operations on sets.
 
-  `MapSet`s can also be constructed starting from other collection-type data
+  Sets can also be constructed starting from other collection-type data
   structures: for example, see `MapSet.new/1` or `Enum.into/2`.
-
-  `MapSet` is built on top of `Map`, this means that they share many properties,
-  including logarithmic time complexity. See the documentation for `Map` for more
-  information on its execution time complexity.
   """
 
-  # MapSets have an underlying Map. MapSet elements are keys of said map,
-  # and this empty list is their associated dummy value.
-  @dummy_value []
-
   @type value :: term
 
-  @opaque t(value) :: %__MODULE__{map: %{optional(value) => []}}
+  @opaque t(value) :: %__MODULE__{map: %{optional(value) => true}}
   @type t :: t(term)
 
-  # TODO: Remove version key on v2.0
-  defstruct map: %{}, version: 2
+  defstruct map: %{}
 
   @doc """
   Returns a new set.
 
   ## Examples
 
-      iex> MapSet.new()
+      iex> MapSet.new
       #MapSet<[]>
 
   """
@@ -83,22 +62,19 @@ defmodule MapSet do
       #MapSet<[1, 2, 3]>
 
   """
-  @spec new(Enum.t()) :: t
-  def new(enumerable)
-
-  def new(%__MODULE__{} = map_set), do: map_set
-
+  @spec new(Enum.t) :: t
+  def new(%__MODULE__{} = mapset), do: mapset
   def new(enumerable) do
     map =
       enumerable
-      |> Enum.to_list()
-      |> new_from_list([])
+      |> Enum.to_list
+      |> do_new([])
 
     %MapSet{map: map}
   end
 
   @doc """
-  Creates a set from an enumerable via the transformation function.
+  Creates a mapset from an enumerable via the transformation function.
 
   ## Examples
 
@@ -106,53 +82,51 @@ defmodule MapSet do
       #MapSet<[2, 4]>
 
   """
-  @spec new(Enum.t(), (term -> val)) :: t(val) when val: value
+  @spec new(Enum.t, (term -> val)) :: t(val) when val: value
   def new(enumerable, transform) when is_function(transform, 1) do
     map =
       enumerable
-      |> Enum.to_list()
-      |> new_from_list_transform(transform, [])
+      |> Enum.to_list
+      |> do_new_transform(transform, [])
 
     %MapSet{map: map}
   end
 
-  defp new_from_list([], acc) do
-    Map.new(acc)
+  defp do_new([], acc) do
+    :maps.from_list(acc)
+  end
+  defp do_new([item | rest], acc) do
+    do_new(rest, [{item, true} | acc])
   end
 
-  defp new_from_list([element | rest], acc) do
-    new_from_list(rest, [{element, @dummy_value} | acc])
+  defp do_new_transform([], _fun, acc) do
+    :maps.from_list(acc)
   end
-
-  defp new_from_list_transform([], _fun, acc) do
-    Map.new(acc)
-  end
-
-  defp new_from_list_transform([element | rest], fun, acc) do
-    new_from_list_transform(rest, fun, [{fun.(element), @dummy_value} | acc])
+  defp do_new_transform([item | rest], fun, acc) do
+    do_new_transform(rest, fun, [{fun.(item), true} | acc])
   end
 
   @doc """
-  Deletes `value` from `map_set`.
+  Deletes `value` from `set`.
 
-  Returns a new set which is a copy of `map_set` but without `value`.
+  Returns a new set which is a copy of `set` but without `value`.
 
   ## Examples
 
-      iex> map_set = MapSet.new([1, 2, 3])
-      iex> MapSet.delete(map_set, 4)
+      iex> set = MapSet.new([1, 2, 3])
+      iex> MapSet.delete(set, 4)
       #MapSet<[1, 2, 3]>
-      iex> MapSet.delete(map_set, 2)
+      iex> MapSet.delete(set, 2)
       #MapSet<[1, 3]>
 
   """
   @spec delete(t(val1), val2) :: t(val1) when val1: value, val2: value
-  def delete(%MapSet{map: map} = map_set, value) do
-    %{map_set | map: Map.delete(map, value)}
+  def delete(%MapSet{map: map} = set, value) do
+    %{set | map: Map.delete(map, value)}
   end
 
   @doc """
-  Returns a set that is `map_set1` without the members of `map_set2`.
+  Returns a set that is `set1` without the members of `set2`.
 
   ## Examples
 
@@ -161,40 +135,40 @@ defmodule MapSet do
 
   """
   @spec difference(t(val1), t(val2)) :: t(val1) when val1: value, val2: value
-  def difference(map_set1, map_set2)
+  def difference(mapset1, mapset2)
 
-  # If the first set is less than twice the size of the second map, it is fastest
-  # to re-accumulate elements in the first set that are not present in the second set.
+  # If the first set is less than twice the size of the second map,
+  # it is fastest to re-accumulate items in the first set that are not
+  # present in the second set.
   def difference(%MapSet{map: map1}, %MapSet{map: map2})
       when map_size(map1) < map_size(map2) * 2 do
-    map =
-      map1
-      |> :maps.iterator()
-      |> :maps.next()
-      |> filter_not_in(map2, [])
+    map = map1
+    |> Map.keys
+    |> filter_not_in(map2)
 
     %MapSet{map: map}
   end
 
   # If the second set is less than half the size of the first set, it's fastest
-  # to simply iterate through each element in the second set, deleting them from
+  # to simply iterate through each item in the second set, deleting them from
   # the first set.
-  def difference(%MapSet{map: map1} = map_set, %MapSet{map: map2}) do
-    %{map_set | map: Map.drop(map1, Map.keys(map2))}
+  def difference(%MapSet{map: map1}, %MapSet{map: map2}) do
+    %MapSet{map: Map.drop(map1, Map.keys(map2))}
   end
 
-  defp filter_not_in(:none, _map2, acc), do: Map.new(acc)
-
-  defp filter_not_in({key, _val, iter}, map2, acc) do
-    if :erlang.is_map_key(key, map2) do
-      filter_not_in(:maps.next(iter), map2, acc)
+  defp filter_not_in(keys, map2, acc \\ [])
+  defp filter_not_in([], _map2, acc), do: :maps.from_list(acc)
+  defp filter_not_in([key | rest], map2, acc) do
+    acc = if Map.has_key?(map2, key) do
+      acc
     else
-      filter_not_in(:maps.next(iter), map2, [{key, @dummy_value} | acc])
+      [{key, true} | acc]
     end
+    filter_not_in(rest, map2, acc)
   end
 
   @doc """
-  Checks if `map_set1` and `map_set2` have no members in common.
+  Checks if `set1` and `set2` have no members in common.
 
   ## Examples
 
@@ -209,21 +183,24 @@ defmodule MapSet do
     {map1, map2} = order_by_size(map1, map2)
 
     map1
-    |> :maps.iterator()
-    |> :maps.next()
+    |> Map.keys
     |> none_in?(map2)
   end
 
-  defp none_in?(:none, _), do: true
-
-  defp none_in?({key, _val, iter}, map2) do
-    not :erlang.is_map_key(key, map2) and none_in?(:maps.next(iter), map2)
+  defp none_in?([], _) do
+    true
+  end
+  defp none_in?([key | rest], map2) do
+    case Map.has_key?(map2, key) do
+      true -> false
+      false -> none_in?(rest, map2)
+    end
   end
 
   @doc """
   Checks if two sets are equal.
 
-  The comparison between elements must be done using `===/2`.
+  The comparison between elements must be done using `===`.
 
   ## Examples
 
@@ -234,18 +211,12 @@ defmodule MapSet do
 
   """
   @spec equal?(t, t) :: boolean
-  def equal?(%MapSet{map: map1, version: version}, %MapSet{map: map2, version: version}) do
+  def equal?(%MapSet{map: map1}, %MapSet{map: map2}) do
     Map.equal?(map1, map2)
   end
 
-  # Elixir v1.5 change the map representation, so on
-  # version mismatch we need to compare the keys directly.
-  def equal?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    map_size(map1) == map_size(map2) and all_in?(map1, map2)
-  end
-
   @doc """
-  Returns a set containing only members that `map_set1` and `map_set2` have in common.
+  Returns a set containing only members that `set1` and `set2` have in common.
 
   ## Examples
 
@@ -257,13 +228,14 @@ defmodule MapSet do
 
   """
   @spec intersection(t(val), t(val)) :: t(val) when val: value
-  def intersection(%MapSet{map: map1} = map_set, %MapSet{map: map2}) do
+  def intersection(%MapSet{map: map1}, %MapSet{map: map2}) do
     {map1, map2} = order_by_size(map1, map2)
-    %{map_set | map: Map.take(map2, Map.keys(map1))}
+
+    %MapSet{map: Map.take(map2, Map.keys(map1))}
   end
 
   @doc """
-  Checks if `map_set` contains `value`.
+  Checks if `set` contains `value`.
 
   ## Examples
 
@@ -275,11 +247,11 @@ defmodule MapSet do
   """
   @spec member?(t, value) :: boolean
   def member?(%MapSet{map: map}, value) do
-    :erlang.is_map_key(value, map)
+    Map.has_key?(map, value)
   end
 
   @doc """
-  Inserts `value` into `map_set` if `map_set` doesn't already contain it.
+  Inserts `value` into `set` if `set` doesn't already contain it.
 
   ## Examples
 
@@ -290,12 +262,12 @@ defmodule MapSet do
 
   """
   @spec put(t(val), new_val) :: t(val | new_val) when val: value, new_val: value
-  def put(%MapSet{map: map} = map_set, value) do
-    %{map_set | map: Map.put(map, value, @dummy_value)}
+  def put(%MapSet{map: map} = set, value) do
+    %{set | map: Map.put(map, value, true)}
   end
 
   @doc """
-  Returns the number of elements in `map_set`.
+  Returns the number of elements in `set`.
 
   ## Examples
 
@@ -309,9 +281,9 @@ defmodule MapSet do
   end
 
   @doc """
-  Checks if `map_set1`'s members are all contained in `map_set2`.
+  Checks if `set1`'s members are all contained in `set2`.
 
-  This function checks if `map_set1` is a subset of `map_set2`.
+  This function checks if `set1` is a subset of `set2`.
 
   ## Examples
 
@@ -323,24 +295,26 @@ defmodule MapSet do
   """
   @spec subset?(t, t) :: boolean
   def subset?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    map_size(map1) <= map_size(map2) and all_in?(map1, map2)
+    if map_size(map1) <= map_size(map2) do
+      map1
+      |> Map.keys
+      |> do_subset?(map2)
+    else
+      false
+    end
   end
 
-  defp all_in?(:none, _), do: true
-
-  defp all_in?({key, _val, iter}, map2) do
-    :erlang.is_map_key(key, map2) and all_in?(:maps.next(iter), map2)
-  end
-
-  defp all_in?(map1, map2) when is_map(map1) and is_map(map2) do
-    map1
-    |> :maps.iterator()
-    |> :maps.next()
-    |> all_in?(map2)
+  defp do_subset?([], _), do: true
+  defp do_subset?([key | rest], map2) do
+    if Map.has_key?(map2, key) do
+      do_subset?(rest, map2)
+    else
+      false
+    end
   end
 
   @doc """
-  Converts `map_set` to a list.
+  Converts `set` to a list.
 
   ## Examples
 
@@ -354,7 +328,7 @@ defmodule MapSet do
   end
 
   @doc """
-  Returns a set containing all members of `map_set1` and `map_set2`.
+  Returns a set containing all members of `set1` and `set2`.
 
   ## Examples
 
@@ -363,58 +337,34 @@ defmodule MapSet do
 
   """
   @spec union(t(val1), t(val2)) :: t(val1 | val2) when val1: value, val2: value
-  def union(map_set1, map_set2)
-
-  def union(%MapSet{map: map1, version: version} = map_set, %MapSet{map: map2, version: version}) do
-    %{map_set | map: Map.merge(map1, map2)}
-  end
-
   def union(%MapSet{map: map1}, %MapSet{map: map2}) do
-    map = new_from_list(Map.keys(map1) ++ Map.keys(map2), [])
-    %MapSet{map: map}
+    %MapSet{map: Map.merge(map1, map2)}
   end
 
-  @compile {:inline, [order_by_size: 2]}
   defp order_by_size(map1, map2) when map_size(map1) > map_size(map2), do: {map2, map1}
   defp order_by_size(map1, map2), do: {map1, map2}
 
   defimpl Enumerable do
-    def count(map_set) do
-      {:ok, MapSet.size(map_set)}
-    end
-
-    def member?(map_set, val) do
-      {:ok, MapSet.member?(map_set, val)}
-    end
-
-    def slice(map_set) do
-      size = MapSet.size(map_set)
-      {:ok, size, &Enumerable.List.slice(MapSet.to_list(map_set), &1, &2, size)}
-    end
-
-    def reduce(map_set, acc, fun) do
-      Enumerable.List.reduce(MapSet.to_list(map_set), acc, fun)
-    end
+    def reduce(set, acc, fun), do: Enumerable.List.reduce(MapSet.to_list(set), acc, fun)
+    def member?(set, val),     do: {:ok, MapSet.member?(set, val)}
+    def count(set),            do: {:ok, MapSet.size(set)}
   end
 
   defimpl Collectable do
-    def into(map_set) do
-      fun = fn
-        list, {:cont, x} -> [{x, []} | list]
-        list, :done -> %{map_set | map: Map.merge(map_set.map, Map.new(list))}
+    def into(original) do
+      {original, fn
+        set, {:cont, x} -> MapSet.put(set, x)
+        set, :done -> set
         _, :halt -> :ok
-      end
-
-      {[], fun}
+      end}
     end
   end
 
   defimpl Inspect do
     import Inspect.Algebra
 
-    def inspect(map_set, opts) do
-      opts = %Inspect.Opts{opts | charlists: :as_lists}
-      concat(["#MapSet<", Inspect.List.inspect(MapSet.to_list(map_set), opts), ">"])
+    def inspect(set, opts) do
+      concat ["#MapSet<", Inspect.List.inspect(MapSet.to_list(set), opts), ">"]
     end
   end
 end

lib/elixir/lib/module/checker.ex

@@ -1,317 +0,0 @@
-defmodule Module.Checker do
-  alias Module.ParallelChecker
-
-  @moduledoc false
-
-  def verify(module, cache) do
-    case prepare_module(module) do
-      {:ok, map} ->
-        undefined_and_deprecation_warnings = undefined_and_deprecation_warnings(map, cache)
-        infer_warnings = infer_definitions(map)
-        warnings = infer_warnings ++ undefined_and_deprecation_warnings
-        emit_warnings(warnings)
-
-      :error ->
-        []
-    end
-  end
-
-  defp prepare_module({module, module_map}) when is_map(module_map) do
-    {:ok,
-     %{
-       module: module,
-       file: module_map.file,
-       definitions: module_map.definitions,
-       deprecated: module_map.deprecated,
-       no_warn_undefined: no_warn_undefined(module_map.compile_opts)
-     }}
-  end
-
-  defp prepare_module({module, binary}) when is_binary(binary) do
-    with {:ok, debug_info} <- debug_info(module, binary),
-         {:ok, checker_info} <- checker_chunk(binary) do
-      {:ok,
-       %{
-         module: module,
-         file: debug_info.file,
-         definitions: debug_info.definitions,
-         deprecated: checker_info.deprecated,
-         no_warn_undefined: checker_info.no_warn_undefined
-       }}
-    end
-  end
-
-  defp no_warn_undefined(compile_opts) do
-    for(
-      {:no_warn_undefined, values} <- compile_opts,
-      value <- List.wrap(values),
-      do: value
-    )
-  end
-
-  defp debug_info(module, binary) do
-    with {:ok, {_, [debug_info: chunk]}} <- :beam_lib.chunks(binary, [:debug_info]),
-         {:debug_info_v1, backend, data} <- chunk,
-         {:ok, info} <- backend.debug_info(:elixir_v1, module, data, []) do
-      {:ok, %{definitions: info.definitions, file: info.relative_file}}
-    else
-      _ -> :error
-    end
-  end
-
-  defp checker_chunk(binary) do
-    with {:ok, {_, [{'ExCk', chunk}]}} <- :beam_lib.chunks(binary, ['ExCk']),
-         {:elixir_checker_v1, contents} <- :erlang.binary_to_term(chunk) do
-      deprecated = Enum.map(contents.exports, fn {fun, map} -> {fun, map.deprecated_reason} end)
-      {:ok, %{deprecated: deprecated, no_warn_undefined: contents.no_warn_undefined}}
-    else
-      _ -> :error
-    end
-  end
-
-  defp infer_definitions(map) do
-    results = Module.Types.infer_definitions(map.file, map.module, map.definitions)
-    Enum.flat_map(results, fn {_function, reasons} -> reasons end)
-  end
-
-  defp undefined_and_deprecation_warnings(map, cache) do
-    state = %{
-      cache: cache,
-      file: map.file,
-      module: map.module,
-      no_warn_undefined: merge_no_warn_undefined(map),
-      function: nil,
-      warnings: []
-    }
-
-    state = check_definitions(map.definitions, state)
-
-    state.warnings
-    |> merge_warnings()
-    |> sort_warnings()
-  end
-
-  defp merge_no_warn_undefined(map) do
-    case Code.get_compiler_option(:no_warn_undefined) do
-      :all ->
-        :all
-
-      list when is_list(list) ->
-        map.no_warn_undefined ++ list
-    end
-  end
-
-  defp check_definitions(definitions, state) do
-    Enum.reduce(definitions, state, &check_definition/2)
-  end
-
-  defp check_definition({function, _kind, meta, clauses}, state) do
-    with_file_meta(%{state | function: function}, meta, fn state ->
-      Enum.reduce(clauses, state, &check_clause/2)
-    end)
-  end
-
-  defp with_file_meta(%{file: original_file} = state, meta, fun) do
-    case Keyword.fetch(meta, :file) do
-      {:ok, {meta_file, _}} ->
-        state = fun.(%{state | file: meta_file})
-        %{state | file: original_file}
-
-      :error ->
-        fun.(state)
-    end
-  end
-
-  defp check_clause({_meta, args, _guards, body}, state) do
-    state = check_expr(args, state)
-    check_expr(body, state)
-  end
-
-  # &Mod.fun/arity
-  defp check_expr({:&, meta, [{:/, _, [{{:., _, [module, fun]}, _, []}, arity]}]}, state)
-       when is_atom(module) and is_atom(fun) do
-    check_remote(module, fun, arity, meta, state)
-  end
-
-  # Mod.fun(...)
-  defp check_expr({{:., meta, [module, fun]}, _, args}, state)
-       when is_atom(module) and is_atom(fun) do
-    state = check_remote(module, fun, length(args), meta, state)
-    check_expr(args, state)
-  end
-
-  # %Module{...}
-  defp check_expr({:%, meta, [module, {:%{}, _meta, args}]}, state)
-       when is_atom(module) and is_list(args) do
-    state = check_remote(module, :__struct__, 0, meta, state)
-    check_expr(args, state)
-  end
-
-  # Function call
-  defp check_expr({left, _meta, right}, state) when is_list(right) do
-    state = check_expr(right, state)
-    check_expr(left, state)
-  end
-
-  # {x, y}
-  defp check_expr({left, right}, state) do
-    state = check_expr(right, state)
-    check_expr(left, state)
-  end
-
-  # [...]
-  defp check_expr(list, state) when is_list(list) do
-    Enum.reduce(list, state, &check_expr/2)
-  end
-
-  defp check_expr(_other, state) do
-    state
-  end
-
-  defp check_remote(module, fun, arity, meta, state) do
-    # TODO: In the future we may want to warn for modules defined
-    # in the local context
-    if Keyword.get(meta, :context_module, false) and state.module != module do
-      state
-    else
-      ParallelChecker.preload_module(state.cache, module)
-      check_export(module, fun, arity, meta, state)
-    end
-  end
-
-  defp check_export(module, fun, arity, meta, state) do
-    case ParallelChecker.fetch_export(state.cache, module, fun, arity) do
-      {:ok, :def, reason} ->
-        check_deprecated(module, fun, arity, reason, meta, state)
-
-      {:ok, :defmacro, reason} ->
-        state = warn(meta, state, {:unrequired_module, module, fun, arity})
-        check_deprecated(module, fun, arity, reason, meta, state)
-
-      {:error, :module} ->
-        if warn_undefined?(module, fun, arity, state) do
-          warn(meta, state, {:undefined_module, module, fun, arity})
-        else
-          state
-        end
-
-      {:error, :function} ->
-        if warn_undefined?(module, fun, arity, state) do
-          exports = ParallelChecker.all_exports(state.cache, module)
-          warn(meta, state, {:undefined_function, module, fun, arity, exports})
-        else
-          state
-        end
-    end
-  end
-
-  defp check_deprecated(module, fun, arity, reason, meta, state) do
-    if reason do
-      warn(meta, state, {:deprecated, module, fun, arity, reason})
-    else
-      state
-    end
-  end
-
-  # 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
-
-  defp warn_undefined?(_, _, _, %{no_warn_undefined: :all}) do
-    false
-  end
-
-  defp warn_undefined?(module, fun, arity, state) do
-    not Enum.any?(state.no_warn_undefined, &(&1 == module or &1 == {module, fun, arity}))
-  end
-
-  defp warn(meta, state, warning) do
-    {fun, arity} = state.function
-    location = {state.file, meta[:line] || 0, {state.module, fun, arity}}
-    %{state | warnings: [{__MODULE__, warning, location} | state.warnings]}
-  end
-
-  defp merge_warnings(warnings) do
-    Enum.reduce(warnings, %{}, fn {module, warning, location}, acc ->
-      locations = MapSet.new([location])
-      Map.update(acc, {module, warning}, locations, &MapSet.put(&1, location))
-    end)
-  end
-
-  defp sort_warnings(warnings) do
-    warnings
-    |> Enum.map(fn {{module, warning}, locations} -> {module, warning, Enum.sort(locations)} end)
-    |> Enum.sort()
-  end
-
-  defp emit_warnings(warnings) do
-    Enum.flat_map(warnings, fn {module, warning, locations} ->
-      message = module.format_warning(warning)
-      print_warning([message, ?\n, format_locations(locations)])
-
-      Enum.map(locations, fn {file, line, _mfa} ->
-        {file, line, message}
-      end)
-    end)
-  end
-
-  def format_warning({:undefined_module, module, fun, arity}) do
-    [
-      Exception.format_mfa(module, fun, arity),
-      " is undefined (module ",
-      inspect(module),
-      " is not available or is yet to be defined)"
-    ]
-  end
-
-  def format_warning({:undefined_function, module, fun, arity, exports}) do
-    [
-      Exception.format_mfa(module, fun, arity),
-      " is undefined or private",
-      UndefinedFunctionError.hint_for_loaded_module(module, fun, arity, exports)
-    ]
-  end
-
-  def format_warning({:deprecated, module, fun, arity, reason}) do
-    [
-      Exception.format_mfa(module, fun, arity),
-      " is deprecated. ",
-      reason
-    ]
-  end
-
-  def format_warning({:unrequired_module, module, fun, arity}) do
-    [
-      "you must require ",
-      inspect(module),
-      " before invoking the macro ",
-      Exception.format_mfa(module, fun, arity)
-    ]
-  end
-
-  defp format_locations([location]) do
-    format_location(location)
-  end
-
-  defp format_locations(locations) do
-    [
-      "Found at #{length(locations)} locations:\n",
-      Enum.map(locations, &format_location/1)
-    ]
-  end
-
-  defp format_location({file, line, {module, fun, arity}}) do
-    file = Path.relative_to_cwd(file)
-    line = if line > 0, do: [Integer.to_string(line), ": "], else: []
-    mfa = Exception.format_mfa(module, fun, arity)
-    ["  ", file, ?:, line, mfa, ?\n]
-  end
-
-  defp print_warning(message) do
-    IO.puts(:stderr, [:elixir_errors.warning_prefix(), message])
-  end
-end

lib/elixir/lib/module/locals_tracker.ex

@@ -4,249 +4,356 @@
 #
 # ## Implementation
 #
-# The implementation uses ETS to track all dependencies
-# resembling a graph. The keys and what they point to are:
+# The implementation uses the digraph module to track
+# all dependencies. The graph starts with one main vertex:
 #
-#   * `:reattach` points to `{name, arity}`
-#   * `{:local, {name, arity}}` points to `{{name, arity}, line, macro_dispatch?}`
-#   * `{:import, {name, arity}}` points to `Module`
+# * `:local` - points to local functions
 #
-# This is built on top of the internal module tables.
+# We can also have the following vertices:
+#
+# * `Module` - a module that was invoked via an import
+# * `{name, arity}` - a local function/arity pair
+# * `{:import, name, arity}` - an invoked function/arity import
+#
+# Each of those vertices can associate to other vertices
+# as described below:
+#
+# * `Module`
+#   * in neighbours:  `{:import, name, arity}`
+#
+# * `{name, arity}`
+#   * in neighbours: `:local`, `{name, arity}`
+#   * out neighbours: `{:import, name, arity}`
+#
+# * `{:import, name, arity}`
+#   * in neighbours: `{name, arity}`
+#   * out neighbours: `Module`
+#
+# Note that since this is required for bootstrap, we can't use
+# any of the `GenServer` conveniences.
 defmodule Module.LocalsTracker do
   @moduledoc false
 
-  @defmacros [:defmacro, :defmacrop]
+  @timeout   30_000
+  @behaviour :gen_server
+
+  @type ref :: pid | module
+  @type name :: atom
+  @type name_arity :: {name, arity}
+
+  @type local :: {name, arity}
+  @type import :: {:import, name, arity}
+
+  # Public API
 
   @doc """
-  Adds and tracks defaults for a definition into the tracker.
+  Returns all imported modules that had the given
+  `{name, arity}` invoked.
   """
-  def add_defaults({_set, bag}, kind, {name, arity} = pair, defaults, meta) do
-    for i <- :lists.seq(arity - defaults, arity - 1) do
-      put_edge(bag, {:local, {name, i}}, {pair, get_line(meta), kind in @defmacros})
-    end
-
-    :ok
+  @spec imports_with_dispatch(ref, name_arity) :: [module]
+  def imports_with_dispatch(ref, {name, arity}) do
+    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
+    :digraph.out_neighbours(d, {:import, name, arity})
   end
 
   @doc """
-  Adds a local dispatch from-to the given target.
-  """
-  def add_local({_set, bag}, from, to, meta, macro_dispatch?)
-      when is_tuple(from) and is_tuple(to) and is_boolean(macro_dispatch?) do
-    put_edge(bag, {:local, from}, {to, get_line(meta), macro_dispatch?})
-    :ok
-  end
-
-  @doc """
-  Adds an import dispatch to the given target.
-  """
-  def add_import({set, _bag}, function, module, imported)
-      when is_tuple(function) and is_atom(module) do
-    put_edge(set, {:import, imported}, module)
-    :ok
-  end
-
-  @doc """
-  Yanks a local node. Returns its in and out vertices in a tuple.
-  """
-  def yank({_set, bag}, local) do
-    :lists.usort(take_out_neighbours(bag, {:local, local}))
-  end
-
-  @doc """
-  Reattach a previously yanked node.
-  """
-  def reattach({_set, bag}, tuple, kind, function, out_neighbours, meta) do
-    for out_neighbour <- out_neighbours do
-      put_edge(bag, {:local, function}, out_neighbour)
-    end
-
-    # Make a call from the old function to the new one
-    if function != tuple do
-      put_edge(bag, {:local, function}, {tuple, get_line(meta), kind in @defmacros})
-    end
-
-    # Finally marked the new one as reattached
-    put_edge(bag, :reattach, tuple)
-    :ok
-  end
-
-  # Collecting all conflicting imports with the given functions
-  @doc false
-  def collect_imports_conflicts({set, _bag}, all_defined) do
-    for {pair, _, meta, _} <- all_defined, n = out_neighbour(set, {:import, pair}) do
-      {meta, {n, pair}}
-    end
-  end
-
-  @doc """
-  Collect all unused definitions based on the private
-  given, also accounting the expected number of default
-  clauses a private function have.
-  """
-  def collect_unused_locals({_set, bag}, all_defined, private) do
-    reachable =
-      Enum.reduce(all_defined, %{}, fn {pair, kind, _, _}, acc ->
-        if kind in [:def, :defmacro] do
-          reachable_from(bag, pair, acc)
-        else
-          acc
-        end
-      end)
-
-    reattached = :lists.usort(out_neighbours(bag, :reattach))
-    {unreachable(reachable, reattached, private), collect_warnings(reachable, private)}
-  end
-
-  @doc """
-  Collect undefined functions based on local calls and existing definitions.
-  """
-  def collect_undefined_locals({set, bag}, all_defined) do
-    undefined =
-      for {pair, _, meta, _} <- all_defined,
-          {local, line, macro_dispatch?} <- out_neighbours(bag, {:local, pair}),
-          error = undefined_local_error(set, local, macro_dispatch?),
-          do: {build_meta(line, meta), local, error}
-
-    :lists.usort(undefined)
-  end
-
-  defp undefined_local_error(set, local, true) do
-    case :ets.member(set, {:def, local}) do
-      true -> false
-      false -> :undefined_function
-    end
-  end
-
-  defp undefined_local_error(set, local, false) do
-    try do
-      if :ets.lookup_element(set, {:def, local}, 2) in @defmacros do
-        :incorrect_dispatch
-      else
-        false
-      end
-    catch
-      _, _ -> :undefined_function
-    end
-  end
-
-  defp unreachable(reachable, reattached, private) do
-    for {tuple, kind, _, _} <- private,
-        not reachable?(tuple, kind, reachable, reattached),
-        do: tuple
-  end
-
-  defp reachable?(tuple, :defmacrop, reachable, reattached) do
-    # All private micros are unreachable unless they have been
-    # reattached and they are reachable.
-    :lists.member(tuple, reattached) and Map.has_key?(reachable, tuple)
-  end
-
-  defp reachable?(tuple, :defp, reachable, _reattached) do
-    Map.has_key?(reachable, tuple)
-  end
-
-  defp collect_warnings(reachable, private) do
-    :lists.foldl(&collect_warnings(&1, &2, reachable), [], private)
-  end
-
-  defp collect_warnings({_, _, false, _}, acc, _reachable) do
-    acc
-  end
-
-  defp collect_warnings({tuple, kind, meta, 0}, acc, reachable) do
-    if Map.has_key?(reachable, tuple) do
-      acc
-    else
-      [{meta, {:unused_def, tuple, kind}} | acc]
-    end
-  end
-
-  defp collect_warnings({tuple, kind, meta, default}, acc, reachable) when default > 0 do
-    {name, arity} = tuple
-    min = arity - default
-    max = arity
-
-    case min_reachable_default(max, min, :none, name, reachable) do
-      :none -> [{meta, {:unused_def, tuple, kind}} | acc]
-      ^min -> acc
-      ^max -> [{meta, {:unused_args, tuple}} | acc]
-      diff -> [{meta, {:unused_args, tuple, diff}} | acc]
-    end
-  end
-
-  defp min_reachable_default(max, min, last, name, reachable) when max >= min do
-    case Map.has_key?(reachable, {name, max}) do
-      true -> min_reachable_default(max - 1, min, max, name, reachable)
-      false -> min_reachable_default(max - 1, min, last, name, reachable)
-    end
-  end
-
-  defp min_reachable_default(_max, _min, last, _name, _reachable) do
-    last
-  end
-
-  @doc """
-  Returns all local nodes reachable from `vertex`.
+  Returns all locals that are reachable.
 
   By default, all public functions are reachable.
   A private function is only reachable if it has
   a public function that it invokes directly.
   """
-  def reachable_from({_, bag}, local) do
-    bag
-    |> reachable_from(local, %{})
-    |> Map.keys()
+  @spec reachable(ref) :: [local]
+  def reachable(ref) do
+    reachable_from(:gen_server.call(to_pid(ref), :digraph, @timeout), :local)
   end
 
-  defp reachable_from(bag, local, vertices) do
-    vertices = Map.put(vertices, local, true)
+  defp reachable_from(d, starting) do
+    :sets.to_list(reduce_reachable(d, starting, :sets.new))
+  end
 
-    Enum.reduce(out_neighbours(bag, {:local, local}), vertices, fn {local, _line, _}, acc ->
-      case acc do
-        %{^local => true} -> acc
-        _ -> reachable_from(bag, local, acc)
+  defp reduce_reachable(d, vertex, vertices) do
+    neighbours = :digraph.out_neighbours(d, vertex)
+    neighbours = (for {_, _} = t <- neighbours, do: t) |> :sets.from_list
+    remaining  = :sets.subtract(neighbours, vertices)
+    vertices   = :sets.union(neighbours, vertices)
+    :sets.fold(&reduce_reachable(d, &1, &2), vertices, remaining)
+  end
+
+  defp to_pid(pid) when is_pid(pid),  do: pid
+  defp to_pid(mod) when is_atom(mod) do
+    table = :elixir_module.data_table(mod)
+    :ets.lookup_element(table, {:elixir, :locals_tracker}, 2)
+  end
+
+  # Internal API
+
+  # Starts the tracker and returns its PID.
+  @doc false
+  def start_link do
+    :gen_server.start_link(__MODULE__, [], [])
+  end
+
+  # Adds a definition into the tracker. A public
+  # definition is connected with the :local node
+  # while a private one is left unreachable until
+  # a call is made to.
+  @doc false
+  def add_definition(pid, kind, tuple) when kind in [:def, :defp, :defmacro, :defmacrop] do
+    :gen_server.cast(pid, {:add_definition, kind, tuple})
+  end
+
+  # Adds and tracks defaults for a definition into the tracker.
+  @doc false
+  def add_defaults(pid, kind, tuple, defaults) when kind in [:def, :defp, :defmacro, :defmacrop] do
+    :gen_server.cast(pid, {:add_defaults, kind, tuple, defaults})
+  end
+
+  # Adds a local dispatch to the given target.
+  def add_local(pid, to) when is_tuple(to) do
+    :gen_server.cast(pid, {:add_local, :local, to})
+  end
+
+  # Adds a local dispatch from-to the given target.
+  @doc false
+  def add_local(pid, from, to) when is_tuple(from) and is_tuple(to) do
+    :gen_server.cast(pid, {:add_local, from, to})
+  end
+
+  # Adds an import dispatch to the given target.
+  @doc false
+  def add_import(pid, function, module, target) when is_atom(module) and is_tuple(target) do
+    :gen_server.cast(pid, {:add_import, function, module, target})
+  end
+
+  # Yanks a local node. Returns its in and out vertices in a tuple.
+  @doc false
+  def yank(pid, local) do
+    :gen_server.call(to_pid(pid), {:yank, local}, @timeout)
+  end
+
+  # Reattach a previously yanked node
+  @doc false
+  def reattach(pid, kind, tuple, neighbours) do
+    :gen_server.cast(to_pid(pid), {:reattach, kind, tuple, neighbours})
+  end
+
+  # Collecting all conflicting imports with the given functions
+  @doc false
+  def collect_imports_conflicts(pid, all_defined) do
+    d = :gen_server.call(pid, :digraph, @timeout)
+
+    for {name, arity} <- all_defined,
+        :digraph.in_neighbours(d, {:import, name, arity}) != [],
+        n = :digraph.out_neighbours(d, {:import, name, arity}),
+        n != [] do
+      {n, name, arity}
+    end
+  end
+
+  # Collect all unused definitions based on the private
+  # given also accounting the expected amount of default
+  # clauses a private function have.
+  @doc false
+  def collect_unused_locals(ref, private) do
+    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
+    {unreachable(d, private), collect_warnings(d, private)}
+  end
+
+  defp unreachable(d, private) do
+    unreachable = for {tuple, _, _} <- private, do: tuple
+
+    private =
+      for {tuple, :defp, _} <- private do
+        neighbours = :digraph.in_neighbours(d, tuple)
+        neighbours = for {_, _} = t <- neighbours, do: t
+        {tuple, :sets.from_list(neighbours)}
       end
-    end)
+
+    reduce_unreachable(private, [], :sets.from_list(unreachable))
   end
 
-  defp get_line(meta), do: Keyword.get(meta, :line)
-
-  defp build_meta(nil, _meta), do: []
-
-  # We need to transform any file annotation in the function
-  # definition into a keep annotation that is used by the
-  # error handling system in order to respect line/file.
-  defp build_meta(line, meta) do
-    case Keyword.get(meta, :file) do
-      {file, _} -> [keep: {file, line}]
-      _ -> [line: line]
+  defp reduce_unreachable([{vertex, callers} | t], acc, unreachable) do
+    if :sets.is_subset(callers, unreachable) do
+      reduce_unreachable(t, [{vertex, callers} | acc], unreachable)
+    else
+      reduce_unreachable(acc ++ t, [], :sets.del_element(vertex, unreachable))
     end
   end
 
-  ## Lightweight digraph implementation
-
-  defp put_edge(d, from, to) do
-    :ets.insert(d, {from, to})
+  defp reduce_unreachable([], _acc, unreachable) do
+    :sets.to_list(unreachable)
   end
 
-  defp out_neighbour(d, from) do
-    try do
-      :ets.lookup_element(d, from, 2)
-    catch
-      :error, :badarg -> nil
+  defp collect_warnings(d, private) do
+    reachable = reachable_from(d, :local)
+    :lists.foldl(&collect_warnings(&1, &2, reachable), [], private)
+  end
+
+  defp collect_warnings({tuple, kind, 0}, acc, reachable) do
+    if :lists.member(tuple, reachable) do
+      acc
+    else
+      [{:unused_def, tuple, kind} | acc]
     end
   end
 
-  defp out_neighbours(d, from) do
-    try do
-      :ets.lookup_element(d, from, 2)
-    catch
-      :error, :badarg -> []
+  defp collect_warnings({tuple, kind, default}, acc, reachable) when default > 0 do
+    {name, arity} = tuple
+    min = arity - default
+    max = arity
+
+    invoked = for {n, a} <- reachable, n == name, a in min..max, do: a
+
+    if invoked == [] do
+      [{:unused_def, tuple, kind} | acc]
+    else
+      case :lists.min(invoked) - min do
+        0 -> acc
+        ^default -> [{:unused_args, tuple} | acc]
+        unused_args -> [{:unused_args, tuple, unused_args} | acc]
+      end
     end
   end
 
-  defp take_out_neighbours(d, from) do
-    Keyword.values(:ets.take(d, from))
+  @doc false
+  def cache_env(pid, env) do
+    :gen_server.call(pid, {:cache_env, env}, @timeout)
+  end
+
+  @doc false
+  def get_cached_env(pid, ref) do
+    :gen_server.call(pid, {:get_cached_env, ref}, @timeout)
+  end
+
+  # Stops the gen server
+  @doc false
+  def stop(pid) do
+    :gen_server.cast(pid, :stop)
+  end
+
+  # Callbacks
+
+  def init([]) do
+    d = :digraph.new([:protected])
+    :digraph.add_vertex(d, :local)
+    {:ok, {d, []}}
+  end
+
+  @doc false
+  def handle_call({:cache_env, env}, _from, {d, cache}) do
+    case cache do
+      [{i, ^env} | _] ->
+        {:reply, i, {d, cache}}
+      t ->
+        i = length(t)
+        {:reply, i, {d, [{i, env} | t]}}
+    end
+  end
+
+  def handle_call({:get_cached_env, ref}, _from, {_, cache} = state) do
+    {^ref, env} = :lists.keyfind(ref, 1, cache)
+    {:reply, env, state}
+  end
+
+  def handle_call({:yank, local}, _from, {d, _} = state) do
+    out_vertices = :digraph.out_neighbours(d, local)
+    :digraph.del_edges(d, :digraph.out_edges(d, local))
+    {:reply, {[], out_vertices}, state}
+  end
+
+  def handle_call(:digraph, _from, {d, _} = state) do
+    {:reply, d, state}
+  end
+
+  @doc false
+  def handle_info(_msg, state) do
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_local, from, to}, {d, _} = state) do
+    handle_add_local(d, from, to)
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_import, function, module, {name, arity}}, {d, _} = state) do
+    handle_import(d, function, module, name, arity)
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_definition, kind, tuple}, {d, _} = state) do
+    handle_add_definition(d, kind, tuple)
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_defaults, kind, {name, arity}, defaults}, {d, _} = state) do
+    for i <- :lists.seq(arity - defaults, arity - 1) do
+      handle_add_definition(d, kind, {name, i})
+      handle_add_local(d, {name, i}, {name, i + 1})
+    end
+    {:noreply, state}
+  end
+
+  def handle_cast({:reattach, _kind, tuple, {in_neigh, out_neigh}}, {d, _} = state) do
+    for from <- in_neigh do
+      :digraph.add_vertex(d, from)
+      replace_edge!(d, from, tuple)
+    end
+
+    for to <- out_neigh do
+      :digraph.add_vertex(d, to)
+      replace_edge!(d, tuple, to)
+    end
+
+    {:noreply, state}
+  end
+
+  def handle_cast(:stop, state) do
+    {:stop, :normal, state}
+  end
+
+  @doc false
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  @doc false
+  def code_change(_old, state, _extra) do
+    {:ok, state}
+  end
+
+  defp handle_import(d, function, module, name, arity) do
+    :digraph.add_vertex(d, module)
+
+    tuple = {:import, name, arity}
+    :digraph.add_vertex(d, tuple)
+    replace_edge!(d, tuple, module)
+
+    if function != nil do
+      replace_edge!(d, function, tuple)
+    end
+
+    :ok
+  end
+
+  defp handle_add_local(d, from, to) do
+    :digraph.add_vertex(d, to)
+    replace_edge!(d, from, to)
+  end
+
+  defp handle_add_definition(d, public, tuple) when public in [:def, :defmacro] do
+    :digraph.add_vertex(d, tuple)
+    replace_edge!(d, :local, tuple)
+  end
+
+  defp handle_add_definition(d, private, tuple) when private in [:defp, :defmacrop] do
+    :digraph.add_vertex(d, tuple)
+  end
+
+  defp replace_edge!(d, from, to) do
+    _ = unless :lists.member(to, :digraph.out_neighbours(d, from)) do
+      [:"$e" | _] = :digraph.add_edge(d, from, to)
+    end
+    :ok
   end
 end

lib/elixir/lib/module/parallel_checker.ex

@@ -1,296 +0,0 @@
-defmodule Module.ParallelChecker do
-  @moduledoc false
-
-  @type cache() :: {pid(), :ets.tid()}
-  @type warning() :: term()
-  @type kind() :: :def | :defmacro
-
-  @doc """
-  Receives pairs of module maps and BEAM binaries. In parallel it verifies
-  the modules and adds the ExCk chunk to the binaries. Returns the updated
-  binaries and a list of warnings from the verification.
-  """
-  @spec verify([{map(), binary()}], [{module(), binary()}], pos_integer()) :: [warning()]
-  def verify(compiled_modules, runtime_binaries, schedulers \\ nil) do
-    compiled_maps = Enum.map(compiled_modules, fn {map, _binary} -> {map.module, map} end)
-    check_modules = compiled_maps ++ runtime_binaries
-
-    schedulers = schedulers || max(:erlang.system_info(:schedulers_online), 2)
-    {:ok, server} = :gen_server.start_link(__MODULE__, [check_modules, self(), schedulers], [])
-    preload_cache(get_ets(server), check_modules)
-    start(server)
-
-    collect_results(length(check_modules), [])
-  end
-
-  defp collect_results(0, warnings) do
-    warnings
-  end
-
-  defp collect_results(count, warnings) do
-    receive do
-      {__MODULE__, _module, new_warnings} ->
-        collect_results(count - 1, new_warnings ++ warnings)
-    end
-  end
-
-  @doc """
-  Preloads a module into the cache. Call this function before any other
-  cache lookups for the module.
-  """
-  @spec preload_module(cache(), module()) :: :ok
-  def preload_module({server, ets}, module) do
-    case :ets.lookup(ets, {:cached, module}) do
-      [{_key, _}] -> :ok
-      [] -> cache_module({server, ets}, module)
-    end
-  end
-
-  @doc """
-  Returns the export kind and deprecation reason for the given MFA from
-  the cache. If the module does not exist return `{:error, :module}`,
-  or if the function does not exist return `{:error, :function}`.
-  """
-  @spec fetch_export(cache(), module(), atom(), arity()) ::
-          {:ok, kind(), binary() | nil} | {:error, :function | :module}
-  def fetch_export({_server, ets}, module, fun, arity) do
-    case :ets.lookup(ets, {:cached, module}) do
-      [{_key, true}] ->
-        case :ets.lookup(ets, {:export, {module, fun, arity}}) do
-          [{_key, kind, reason}] -> {:ok, kind, reason}
-          [] -> {:error, :function}
-        end
-
-      [{_key, false}] ->
-        {:error, :module}
-    end
-  end
-
-  @doc """
-  Returns all exported functions and macros for the given module from
-  the cache.
-  """
-  @spec all_exports(cache(), module()) :: [{atom(), arity()}]
-  def all_exports({_server, ets}, module) do
-    # This is only called after we get a deprecation notice
-    # so we can assume it's a cached module
-    [{_key, exports}] = :ets.lookup(ets, {:all_exports, module})
-
-    exports
-    |> Enum.map(fn {function, _kind} -> function end)
-    |> Enum.sort()
-  end
-
-  def init([modules, send_results, schedulers]) do
-    ets = :ets.new(:checker_cache, [:set, :public, {:read_concurrency, true}])
-
-    state = %{
-      ets: ets,
-      waiting: %{},
-      send_results: send_results,
-      modules: modules,
-      spawned: 0,
-      schedulers: schedulers
-    }
-
-    {:ok, state}
-  end
-
-  def handle_call({:lock, module}, from, %{waiting: waiting} = state) do
-    case waiting do
-      %{^module => froms} ->
-        waiting = Map.put(state.waiting, module, [from | froms])
-        {:noreply, %{state | waiting: waiting}}
-
-      %{} ->
-        waiting = Map.put(state.waiting, module, [])
-        {:reply, true, %{state | waiting: waiting}}
-    end
-  end
-
-  def handle_call({:unlock, module}, _from, %{waiting: waiting} = state) do
-    froms = Map.fetch!(waiting, module)
-    Enum.each(froms, &:gen_server.reply(&1, false))
-    waiting = Map.delete(waiting, module)
-    {:reply, :ok, %{state | waiting: waiting}}
-  end
-
-  def handle_call(:get_ets, _from, %{ets: ets} = state) do
-    {:reply, ets, state}
-  end
-
-  def handle_cast(:start, %{modules: []} = state) do
-    {:stop, :normal, state}
-  end
-
-  def handle_cast(:start, state) do
-    {:noreply, spawn_checkers(state)}
-  end
-
-  def handle_info({__MODULE__, :done}, state) do
-    state = %{state | spawned: state.spawned - 1}
-
-    if state.spawned == 0 and state.modules == [] do
-      {:stop, :normal, state}
-    else
-      state = spawn_checkers(state)
-      {:noreply, state}
-    end
-  end
-
-  defp lock(server, module) do
-    :gen_server.call(server, {:lock, module}, :infinity)
-  end
-
-  defp unlock(server, module) do
-    :gen_server.call(server, {:unlock, module})
-  end
-
-  defp get_ets(server) do
-    :gen_server.call(server, :get_ets)
-  end
-
-  defp start(server) do
-    :gen_server.cast(server, :start)
-  end
-
-  defp preload_cache(ets, modules) do
-    Enum.each(modules, fn
-      {_module, map} when is_map(map) -> cache_from_module_map(ets, map)
-      {module, binary} when is_binary(binary) -> cache_from_chunk(ets, module, binary)
-    end)
-  end
-
-  defp spawn_checkers(%{modules: []} = state) do
-    state
-  end
-
-  defp spawn_checkers(%{spawned: spawned, schedulers: schedulers} = state)
-       when spawned >= schedulers do
-    state
-  end
-
-  defp spawn_checkers(%{modules: [{module, _} = verify | modules]} = state) do
-    parent = self()
-    ets = state.ets
-    send_results_pid = state.send_results
-
-    spawn_link(fn ->
-      warnings = Module.Checker.verify(verify, {parent, ets})
-      send(send_results_pid, {__MODULE__, module, warnings})
-      send(parent, {__MODULE__, :done})
-    end)
-
-    spawn_checkers(%{state | modules: modules, spawned: state.spawned + 1})
-  end
-
-  defp cache_module({server, ets}, module) do
-    if lock(server, module) do
-      cache_from_chunk(ets, module) || cache_from_info(ets, module)
-      unlock(server, module)
-    end
-  end
-
-  defp cache_from_chunk(ets, module) do
-    case :code.get_object_code(module) do
-      {^module, binary, _filename} -> cache_from_chunk(ets, module, binary)
-      _other -> false
-    end
-  end
-
-  defp cache_from_chunk(ets, module, binary) do
-    with {:ok, {_, [{'ExCk', chunk}]}} <- :beam_lib.chunks(binary, ['ExCk']),
-         {:elixir_checker_v1, contents} <- :erlang.binary_to_term(chunk) do
-      cache_chunk(ets, module, contents.exports)
-      true
-    else
-      _ -> false
-    end
-  end
-
-  defp cache_from_module_map(ets, map) do
-    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
-
-  defp cache_from_info(ets, module) do
-    if Code.ensure_loaded?(module) do
-      exports = info_exports(module)
-      deprecated = info_deprecated(module)
-      cache_info(ets, module, exports, deprecated)
-    else
-      :ets.insert(ets, {{:cached, module}, false})
-    end
-  end
-
-  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})
-    )
-  rescue
-    _ -> Map.new(Enum.map(module.module_info(:exports), &{&1, :def}))
-  end
-
-  defp info_deprecated(module) do
-    Map.new(module.__info__(:deprecated))
-  rescue
-    _ -> %{}
-  end
-
-  defp cache_info(ets, module, exports, deprecated) do
-    exports =
-      Enum.map(exports, fn {{fun, arity}, kind} ->
-        reason = Map.get(deprecated, {fun, arity})
-        :ets.insert(ets, {{:export, {module, fun, arity}}, kind, reason})
-
-        {{fun, arity}, kind}
-      end)
-
-    :ets.insert(ets, {{:all_exports, module}, exports})
-    :ets.insert(ets, {{:cached, module}, true})
-  end
-
-  defp cache_chunk(ets, module, exports) do
-    exports =
-      Enum.map(exports, fn {{fun, arity}, %{kind: kind, deprecated_reason: reason}} ->
-        :ets.insert(ets, {{:export, {module, fun, arity}}, kind, reason})
-
-        {{fun, arity}, kind}
-      end)
-
-    :ets.insert(ets, {{:export, {module, :__info__, 1}}, :def, nil})
-    exports = [{{:__info__, 1}, :def} | exports]
-
-    :ets.insert(ets, {{:all_exports, module}, exports})
-    :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
-        [{function, kind}]
-      else
-        []
-      end
-    end)
-  end
-end