Release v1.5.0-rc.2

Tables named after modules are very likely to be used
the application itself, which can lead to conflicts in
scenarios such as code reloading.

Closes #6361

.appveyor.yml

@@ -0,0 +1,9 @@
+version: 1-{branch}+{build}
+
+build_script:
+  - cmd: C:\MinGW\msys\1.0\bin\make
+  - cmd: rmdir /s /q .git
+before_test:
+  - cmd: set PATH=%PATH%;C:\Program Files\erl8.3\erts-8.3\bin
+test_script:
+  - cmd: C:\MinGW\msys\1.0\bin\make --keep-going test_windows

.cirrus.yml

@@ -1,50 +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_freebsd_task:
-  <<: *DEFAULT_TEST_SETTINGS
-
-  name: FreeBSD 13.0
-  alias: FreeBSD Stable
-
-  freebsd_instance:
-    image_family: freebsd-13-0
-    cpu: 8
-    memory: 7424Mi
-
-  env:
-    CHECK_REPRODUCIBLE: true
-    LC_ALL: en_US.UTF-8
-    PATH: $PATH:/usr/local/lib/erlang24/bin
-
-  install_script:
-    - pkg install -y erlang-runtime24 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,19 +0,0 @@
-[
-  inputs: [
-    "lib/*/{lib,unicode,test}/**/*.{ex,exs}",
-    "lib/*/*.exs",
-    "lib/ex_unit/examples/*.exs",
-    ".formatter.exs"
-  ],
-  locals_without_parens: [
-    # Formatter tests
-    assert_format: 2,
-    assert_format: 3,
-    assert_same: 1,
-    assert_same: 2,
-
-    # Errors tests
-    assert_eval_raise: 3
-  ],
-  normalize_bitstring_modifiers: false
-]

.gitattributes

@@ -1,3 +1 @@
 lib/elixir/test/elixir/fixtures/*.txt text eol=lf
-*.ex diff=elixir
-*.exs diff=elixir

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +0,0 @@
----
-blank_issues_enabled: true
-
-contact_links:
-  - name: Discuss proposals
-    url: https://groups.google.com/g/elixir-lang-core
-    about: Send proposals for new ideas to our mailing list
-
-  - name: Ask questions and support
-    url: https://elixirforum.com/
-    about: Ask questions, provide support and more on Elixir Forum

.github/ISSUE_TEMPLATE/issue.yml

@@ -1,53 +0,0 @@
----
-name: Report an issue
-description:
-  Tell us about something that is not working the way we (probably) intend
-body:
-  - type: markdown
-    attributes:
-      value: >
-        Thank you for contributing to Elixir! :heart:
-
-
-        Please, do not use this form for guidance, questions or support.
-        Try instead in [Elixir Forum](https://elixirforum.com),
-        the [IRC Chat](https://web.libera.chat/#elixir),
-        [Stack Overflow](https://stackoverflow.com/questions/tagged/elixir),
-        [Slack](https://elixir-slackin.herokuapp.com),
-        [Discord](https://discord.gg/elixir) or in other online communities.
-
-  - type: textarea
-    id: elixir-and-otp-version
-    attributes:
-      label: Elixir and Erlang/OTP versions
-      description: Paste the output of `elixir --version` here.
-    validations:
-      required: true
-
-  - type: input
-    id: os
-    attributes:
-      label: Operating system
-      description: The operating system that this issue is happening on.
-    validations:
-      required: true
-
-  - type: textarea
-    id: current-behavior
-    attributes:
-      label: Current behavior
-      description: >
-        Include code samples, errors, and stacktraces if appropriate.
-
-
-        If reporting a bug, please include the reproducing steps.
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: Expected behavior
-      description: A short description on how you expect the code to behave.
-    validations:
-      required: true

.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/ci.yml

@@ -1,129 +0,0 @@
-name: CI
-
-on: [pull_request, push]
-
-env:
-  ELIXIR_ASSERT_TIMEOUT: 2000
-  ELIXIRC_OPTS: "--warnings-as-errors"
-  ERLC_OPTS: "warnings_as_errors"
-  LANG: C.UTF-8
-
-permissions:
-  contents: read
-
-jobs:
-  test_linux:
-    name: Linux, ${{ matrix.otp_release }}, Ubuntu 20.04
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - otp_release: OTP-25.0
-            otp_latest: true
-          - otp_release: OTP-24.3
-          - otp_release: OTP-24.0
-          - otp_release: OTP-23.3
-          - otp_release: OTP-23.0
-          - otp_release: master
-            development: true
-          - otp_release: maint
-            development: true
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 50
-      - name: Install Erlang/OTP
-        run: |
-          cd $RUNNER_TEMP
-          wget -O otp.tar.gz https://repo.hex.pm/builds/otp/ubuntu-20.04/${{ matrix.otp_release }}.tar.gz
-          mkdir -p otp
-          tar zxf otp.tar.gz -C otp --strip-components=1
-          otp/Install -minimal $(pwd)/otp
-          echo "$(pwd)/otp/bin" >> $GITHUB_PATH
-      - name: Compile Elixir
-        run: |
-          rm -rf .git
-          make compile
-          echo "$PWD/bin" >> $GITHUB_PATH
-      - name: Build info
-        run: bin/elixir --version
-      - name: Check format
-        run: make test_formatted && echo "All Elixir source code files are properly formatted."
-      - name: Run Dialyzer
-        run: dialyzer -pa lib/elixir/ebin --build_plt --output_plt elixir.plt --apps lib/elixir/ebin/elixir.beam lib/elixir/ebin/Elixir.Kernel.beam
-      - name: Erlang test suite
-        run: make test_erlang
-        continue-on-error: ${{ matrix.development }}
-      - name: Elixir test suite
-        run: make test_elixir
-        continue-on-error: ${{ matrix.development }}
-      - name: Check reproducible builds
-        run: taskset 1 make check_reproducible
-        if: ${{ matrix.otp_latest }}
-      - name: Build docs
-        if: ${{ matrix.otp_latest }}
-        run: |
-          git config --global advice.detachedHead false
-          EX_DOC_LATEST_STABLE_VERSION=$(curl -s https://hex.pm/api/packages/ex_doc | jq --raw-output '.latest_stable_version')
-          for branch in main v${EX_DOC_LATEST_STABLE_VERSION}; do
-            echo "Building docs with ExDoc ${branch}"
-            cd ..
-            git clone https://github.com/elixir-lang/ex_doc.git --branch ${branch} --depth 1
-            cd ex_doc
-            ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile
-            cd ../elixir/
-            make docs
-            rm -rf ../ex_doc/
-          done
-
-  test_windows:
-    name: Windows, OTP-${{ matrix.otp_release }}, Windows Server 2019
-    strategy:
-      matrix:
-        otp_release: ['23.3']
-    runs-on: windows-2019
-    steps:
-      - name: Configure Git
-        run: git config --global core.autocrlf input
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 50
-      - name: Cache Erlang/OTP package
-        uses: actions/cache@v3
-        with:
-          path: C:\Users\runneradmin\AppData\Local\Temp\chocolatey\erlang
-          key: OTP-${{ matrix.otp_release }}-windows-2019
-      - name: Install Erlang/OTP
-        run: choco install -y erlang --version ${{ matrix.otp_release }}
-      - name: Compile Elixir
-        run: |
-          remove-item '.git' -recurse -force
-          make compile
-      - name: Build info
-        run: bin/elixir --version
-      - name: Check format
-        run: make test_formatted && echo "All Elixir source code files are properly formatted."
-      - name: Erlang test suite
-        run: make --keep-going test_erlang
-      - name: Elixir test suite
-        run: |
-          del c:/Windows/System32/drivers/etc/hosts
-          make --keep-going test_elixir
-
-  check_posix_compliant:
-    name: Check POSIX-compliant
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 50
-      - name: Install Shellcheck
-        run: |
-          sudo apt update
-          sudo apt install -y shellcheck
-      - name: Check POSIX-compliant
-        run: |
-          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"

.github/workflows/notify.exs

@@ -1,72 +0,0 @@
-# #!/usr/bin/env elixir
-[tag] = System.argv()
-
-Mix.install([
-  {:req, "~> 0.2.1"},
-  {:jason, "~> 1.0"}
-])
-
-%{status: 200, body: release} =
-  Req.get!("https://api.github.com/repos/elixir-lang/elixir/releases/tags/#{tag}")
-
-if release["draft"] do
-  raise "cannot notify a draft release"
-end
-
-## Notify on elixir-lang-ann
-
-names_and_checksums =
-  for asset <- release["assets"],
-      name = asset["name"],
-      name =~ ~r/.sha\d+sum$/,
-      do: {name, Req.get!(asset["browser_download_url"]).body}
-
-line_items =
-  for {name, checksum_and_name} <- Enum.sort(names_and_checksums) do
-    [checksum | _] = String.split(checksum_and_name, " ")
-    root = Path.rootname(name)
-    "." <> type = Path.extname(name)
-    "  * #{root} - #{type} - #{checksum}\n"
-  end
-
-mail = %{
-  "From" => "jose.valim@dashbit.co",
-  "To" => "elixir-lang-ann@googlegroups.com",
-  "Subject" => "Elixir #{tag} released",
-  "HtmlBody" => "https://github.com/elixir-lang/elixir/releases/tag/#{tag}\n\n#{line_items}",
-  "MessageStream" => "outbound"
-}
-
-if System.get_env("DRYRUN") do
-  IO.puts("MAIL")
-  IO.inspect(mail)
-else
-  headers = %{
-    "X-Postmark-Server-Token" => System.fetch_env!("ELIXIR_LANG_ANN_TOKEN")
-  }
-
-  resp = Req.post!("https://api.postmarkapp.com/email", {:json, mail}, headers: headers)
-  IO.puts("#{resp.status} elixir-lang-ann\n#{inspect(resp.body)}")
-end
-
-## Notify on Elixir Forum
-
-post = %{
-  "title" => "Elixir #{tag} released",
-  "raw" => "https://github.com/elixir-lang/elixir/releases/tag/#{tag}\n\n#{release["body"]}",
-  # Elixir News
-  "category" => 28
-}
-
-if System.get_env("DRYRUN") do
-  IO.puts("POST")
-  IO.inspect(post)
-else
-  headers = %{
-    "api-key" => System.fetch_env!("ELIXIR_FORUM_TOKEN"),
-    "api-username" => "Elixir"
-  }
-
-  resp = Req.post!("https://elixirforum.com/posts.json", {:json, post}, headers: headers)
-  IO.puts("#{resp.status} Elixir Forum\n#{inspect(resp.body)}")
-end

.github/workflows/notify.yml

@@ -1,28 +0,0 @@
-name: Notify
-
-on:
-  release:
-    types:
-      - published
-
-permissions:
-  contents: read
-
-jobs:
-  notify:
-    runs-on: ubuntu-20.04
-    name: Notify
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 50
-      - uses: erlef/setup-beam@v1
-        with:
-          otp-version: '25.0'
-          elixir-version: '1.14.0'
-      - name: Run Elixir script
-        env:
-          ELIXIR_FORUM_TOKEN: ${{ secrets.ELIXIR_FORUM_TOKEN }}
-          ELIXIR_LANG_ANN_TOKEN: ${{ secrets.ELIXIR_LANG_ANN_TOKEN }}
-        run: |
-          elixir .github/workflows/notify.exs ${{ github.ref_name }}

.github/workflows/release.yml

@@ -1,96 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - v*
-
-env:
-  ELIXIR_OPTS: "--warnings-as-errors"
-  ERLC_OPTS: "warnings_as_errors"
-  LANG: C.UTF-8
-
-jobs:
-  create_draft_release:
-    permissions:
-      contents: write
-    runs-on: ubuntu-20.04
-    env:
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - name: Create draft release
-        run: |
-          gh release create \
-            --repo ${{ github.repository }} \
-            --title ${{ github.ref_name }} \
-            --notes '' \
-            --draft \
-            ${{ github.ref_name }}
-  release_pre_built:
-    needs: create_draft_release
-    strategy:
-      fail-fast: true
-      matrix:
-        include:
-          - otp: 23
-            otp_version: 23.3
-          - otp: 24
-            otp_version: 24.3
-          - otp: 25
-            otp_version: 25.0
-            build_docs: build_docs
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 50
-      - uses: erlef/setup-beam@v1
-        with:
-          otp-version: ${{ matrix.otp_version }}
-          version-type: strict
-      - name: Build Elixir Release
-        run: |
-          make Precompiled.zip
-          mv Precompiled.zip elixir-otp-${{ matrix.otp }}.zip
-          shasum -a 1 elixir-otp-${{ matrix.otp }}.zip > elixir-otp-${{ matrix.otp }}.zip.sha1sum
-          shasum -a 256 elixir-otp-${{ matrix.otp }}.zip > elixir-otp-${{ matrix.otp }}.zip.sha256sum
-          echo "$PWD/bin" >> $GITHUB_PATH
-      - name: Upload Pre-built
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh release upload --clobber "${{ github.ref_name }}" \
-            elixir-otp-${{ matrix.otp }}.zip \
-            elixir-otp-${{ matrix.otp }}.zip.sha{1,256}sum
-      - name: Get latest stable ExDoc version
-        if: ${{ matrix.build_docs }}
-        run: |
-          EX_DOC_LATEST_STABLE_VERSION=$(curl -s https://hex.pm/api/packages/ex_doc | jq --raw-output '.latest_stable_version')
-          echo "EX_DOC_LATEST_STABLE_VERSION=${EX_DOC_LATEST_STABLE_VERSION}" >> $GITHUB_ENV
-      - uses: actions/checkout@v3
-        if: ${{ matrix.build_docs }}
-        with:
-          repository: elixir-lang/ex_doc
-          ref: v${{ env.EX_DOC_LATEST_STABLE_VERSION }}
-          path: ex_doc
-      - name: Build ex_doc
-        if: ${{ matrix.build_docs }}
-        run: |
-          mv ex_doc ../ex_doc
-          cd ../ex_doc
-          ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile
-          cd ../elixir
-      - name: Build Docs
-        if: ${{ matrix.build_docs }}
-        run: |
-          make Docs.zip
-          shasum -a 1 Docs.zip > Docs.zip.sha1sum
-          shasum -a 256 Docs.zip > Docs.zip.sha256sum
-      - name: Upload Docs
-        if: ${{ matrix.build_docs }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh release upload --clobber "${{ github.ref_name }}" \
-            Docs.zip \
-            Docs.zip.sha{1,256}sum

.gitignore

@@ -3,6 +3,7 @@
 /lib/*/_build/
 /lib/*/tmp/
 /lib/elixir/src/*_parser.erl
+/lib/elixir/src/elixir.app.src
 /lib/elixir/test/ebin/
 /man/elixir.1
 /man/iex.1

.travis.yml

@@ -0,0 +1,32 @@
+language: erlang
+sudo: false
+
+os: linux
+otp_release: 18.0
+
+matrix:
+  include:
+    - os: linux
+      otp_release: 18.1
+    - os: linux
+      otp_release: 18.2
+    - os: linux
+      otp_release: 18.3
+    - os: linux
+      otp_release: 19.0
+    - os: linux
+      otp_release: 19.1
+    - os: linux
+      otp_release: 19.2
+    - os: linux
+      otp_release: 19.3
+    - os: linux
+      otp_release: 20.0
+
+script: "make compile && rm -rf .git && make test"
+
+notifications:
+  recipients:
+    - jose.valim@plataformatec.com.br
+    - eric.meadows.jonsson@gmail.com
+

CHANGELOG.md

@@ -1,600 +1,354 @@
-# Changelog for Elixir v1.14
-
-Elixir v1.14 brings many improvements to the debugging experience in Elixir
-and data-type inspection. It also includes a new abstraction for easy
-partitioning of processes called `PartitionSupervisor`, as well as improved
-compilation times and error messages.
-
-Elixir v1.14 is the last version to support Erlang/OTP 23. Consider updating
-to Erlang/OTP 24 or Erlang/OTP 25.
-
-## `dbg`
-
-`Kernel.dbg/2` is a new macro that's somewhat similar to `IO.inspect/2`, but
-specifically tailored for **debugging**.
-
-When called, it prints the value of whatever you pass to it, plus the debugged
-code itself as well as its location. This code:
-
-```elixir
-# In my_file.exs
-feature = %{name: :dbg, inspiration: "Rust"}
-dbg(feature)
-dbg(Map.put(feature, :in_version, "1.14.0"))
-```
-
-Prints this:
-
-```shell
-$ elixir my_file.exs
-[my_file.exs:2: (file)]
-feature #=> %{inspiration: "Rust", name: :dbg}
-
-[my_file.exs:3: (file)]
-Map.put(feature, :in_version, "1.14.0") #=> %{in_version: "1.14.0", inspiration: "Rust", name: :dbg}
-```
-
-`dbg/2` can do more. It's a macro, so it *understands Elixir code*. You can see
-that when you pass a series of `|>` pipes to it. `dbg/2` will print the value
-for every step of the pipeline. This code:
-
-```elixir
-# In dbg_pipes.exs
-__ENV__.file
-|> String.split("/", trim: true)
-|> List.last()
-|> File.exists?()
-|> dbg()
-```
-
-Prints this:
-
-```shell
-$ elixir dbg_pipes.exs
-[dbg_pipes.exs:5: (file)]
-__ENV__.file #=> "/home/myuser/dbg_pipes.exs"
-|> String.split("/", trim: true) #=> ["home", "myuser", "dbg_pipes.exs"]
-|> List.last() #=> "dbg_pipes.exs"
-|> File.exists?() #=> true
-```
-
-### IEx and Prying
-
-`dbg/2` supports configurable backends. IEx automatically replaces the default
-backend by one that halts the code execution with `IEx.Pry`, giving developers
-the option to access local variables, imports, and more. This also works with
-pipelines: if you pass a series of `|>` pipe calls to `dbg` (or pipe into it at the
-end, like `|> dbg()`), you'll be able to step through every line in the pipeline.
-
-You can keep the default behaviour by passing the `--no-pry` option to IEx.
-
-## PartitionSupervisor
-
-`PartitionSupervisor` is a new module that implements a new supervisor type. The
-partition supervisor is designed to help with situations where you have a single
-supervised process that becomes a bottleneck. If that process's state can be
-easily partitioned, then you can use `PartitionSupervisor` to supervise multiple
-isolated copies of that process running concurrently, each assigned its own
-partition.
-
-For example, imagine you have an `ErrorReporter` process that you use to report
-errors to a monitoring service.
-
-```elixir
-# Application supervisor:
-children = [
-  # ...,
-  ErrorReporter
-]
-
-Supervisor.start_link(children, strategy: :one_for_one)
-```
-
-As the concurrency of your application goes up, the `ErrorReporter` process
-might receive requests from many other processes and eventually become a
-bottleneck. In a case like this, it could help to spin up multiple copies of the
-`ErrorReporter` process under a `PartitionSupervisor`.
-
-```elixir
-# Application supervisor
-children = [
-  {PartitionSupervisor, child_spec: ErrorReporter, name: Reporters}
-]
-```
-
-The `PartitionSupervisor` will spin up a number of processes equal to
-`System.schedulers_online()` by default (most often one per core). Now, when
-routing requests to `ErrorReporter` processes we can use a `:via` tuple and
-route the requests through the partition supervisor.
-
-```elixir
-partitioning_key = self()
-ErrorReporter.report({:via, PartitionSupervisor, {Reporters, partitioning_key}}, error)
-```
-
-Using `self()` as the partitioning key here means that the same process will
-always report errors to the same `ErrorReporter` process, ensuring a form of
-back-pressure. You can use any term as the partitioning key.
-
-### A Common Example
-
-A common and practical example of a good use case for `PartitionSupervisor` is
-partitioning something like a `DynamicSupervisor`. When starting many processes
-under it, a dynamic supervisor can be a bottleneck, especially if said processes
-take a long time to initialize. Instead of starting a single `DynamicSupervisor`,
-you can start multiple:
-
-```elixir
-children = [
-  {PartitionSupervisor, child_spec: DynamicSupervisor, name: MyApp.DynamicSupervisors}
-]
-
-Supervisor.start_link(children, strategy: :one_for_one)
-```
-
-Now you start processes on the dynamic supervisor for the right partition.
-For instance, you can partition by PID, like in the previous example:
-
-```elixir
-DynamicSupervisor.start_child(
-  {:via, PartitionSupervisor, {MyApp.DynamicSupervisors, self()}},
-  my_child_specification
-)
-```
-
-## Improved errors on binaries and evaluation
-
-Erlang/OTP 25 improved errors on binary construction and evaluation. These improvements
-apply to Elixir as well. Before v1.14, errors when constructing binaries would
-often be hard-to-debug generic "argument errors". With Erlang/OTP 25 and Elixir v1.14,
-more detail is provided for easier debugging. This work is part of [EEP
-54](https://www.erlang.org/eeps/eep-0054).
-
-Before:
-
-```elixir
-int = 1
-bin = "foo"
-int <> bin
-#=> ** (ArgumentError) argument error
-```
-
-Now:
-
-```elixir
-int = 1
-bin = "foo"
-int <> bin
-#=> ** (ArgumentError) construction of binary failed:
-#=>    segment 1 of type 'binary':
-#=>    expected a binary but got: 1
-```
+# Changelog for Elixir v1.5
 
-## Slicing with steps
+Elixir v1.5 brings new features, enhancements and bug fixes to Elixir. It is the first release to leverage features added as part of Erlang/OTP 20. It is also the last release that supports Erlang/OTP 18.
 
-Elixir v1.12 introduced **stepped ranges**, which are ranges where you can
-specify the "step":
+## UTF-8 atoms, function names and variables
 
-```elixir
-Enum.to_list(1..10//3)
-#=> [1, 4, 7, 10]
-```
+Elixir v1.5 supports non-quoted atoms and variables to be in UTF-8 when using Erlang/OTP 20+. For example:
 
-Stepped ranges are particularly useful for numerical operations involving
-vectors and matrices (see [Nx](https://github.com/elixir-nx/nx), for example).
-However, the Elixir standard library was not making use of stepped ranges in its
-APIs. Elixir v1.14 starts to take advantage of steps with support for stepped
-ranges in a couple of functions. One of them is `Enum.slice/2`:
+    test "こんにちは世界" do
+      assert :こんにちは世界
+    end
 
-```elixir
-letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
-Enum.slice(letters, 0..5//2)
-#=> ["a", "c", "e"]
-```
+Or:
 
-`binary_slice/2` (and `binary_slice/3` for completeness) has been added to the
-`Kernel` module, that works with bytes and also support stepped ranges:
+    saudação = "Bom dia!"
 
-```elixir
-binary_slice("Elixir", 1..5//2)
-#=> "lxr"
-```
+Elixir follows the recommendations in [Unicode Annex #31](http://unicode.org/reports/tr31/) to make the language more accessible to other languages and communities. Identifiers must still be a sequence of letters, followed by digits and combining marks. This means symbols, such as mathematical notations and emoji, are not allowed identifiers.
 
-## Expression-based inspection and `Inspect` improvements
+For a complete reference on Elixir syntax, see the [Syntax Reference](https://hexdocs.pm/elixir/syntax-reference.html). For technical details on Unicode support, see [Unicode Syntax](https://hexdocs.pm/elixir/unicode-syntax.html).
 
-In Elixir, it's conventional to implement the `Inspect` protocol for opaque
-structs so that they're inspected with a special notation, resembling this:
+## IEx improvements
 
-```elixir
-MapSet.new([:apple, :banana])
-#MapSet<[:apple, :banana]>
-```
+IEx got many improvements. The autocompletion system is now capable of autocompleting variables and user imports. New helpers have also been added:
 
-This is generally done when the struct content or part of it is private and the
-`%name{...}` representation would reveal fields that are not part of the public
-API.
+  * `exports/1` lists all exports (functions and macros) in a given module
+  * `open/1` opens up the source of a module or function directly in your editor. For example, `open MyApp.Module`
+  * `runtime_info/0` prints general information about the running system, such as number of cores, runtime version, allocation of memory in the VM and more
 
-The downside of the `#name<...>` convention is that *the inspected output is not
-valid Elixir code*. For example, you cannot copy the inspected output and paste
-it into an IEx session.
+IEx also features a breakpoint system for code debugging. The following functions have been added to aid debugging:
 
-Elixir v1.14 changes the convention for some of the standard-library structs.
-The `Inspect` implementation for those structs now returns a string with a valid
-Elixir expression that recreates the struct when evaluated. In the `MapSet`
-example above, this is what we have now:
+  * `break!/2` - sets up a breakpoint for a given `Mod.fun/arity`
+  * `break!/4` - sets up a breakpoint for the given module, function, arity
+  * `breaks/0` - prints all breakpoints and their ids
+  * `continue/0` - continues until the next breakpoint in the same process
+  * `open/0` - opens editor on the current breakpoint
+  * `remove_breaks/0` - removes all breakpoints in all modules
+  * `remove_breaks/1` - removes all breakpoints in a given module
+  * `reset_break/1` - sets the number of stops on the given id to zero
+  * `reset_break/3` - sets the number of stops on the given module, function, arity to zer
+  * `respawn/0` - starts a new shell (breakpoints will ask for permission once more)
+  * `whereami/1` - shows the current location
 
-```elixir
-fruits = MapSet.new([:apple, :banana])
-MapSet.put(fruits, :pear)
-#=> MapSet.new([:apple, :banana, :pear])
-```
+## Exception.blame
 
-The `MapSet.new/1` expression evaluates to exactly the struct that we're
-inspecting. This allows us to hide the internals of `MapSet`, while keeping
-it as valid Elixir code. This expression-based inspection has been
-implemented for `Version.Requirement`, `MapSet`, and `Date.Range`.
+`Exception.blame/3` is a new function in Elixir that is capable of attaching debug information to certain exceptions. Currently this is used to augment `FunctionClauseError`s with a summary of all clauses and which parts of clause match and which ones didn't. For example:
 
-Finally, we have improved the `Inspect` protocol for structs so that
-fields are inspected in the order they are declared in `defstruct`.
-The option `:optional` has also been added when deriving the `Inspect`
-protocol, giving developers more control over the struct representation.
-See the updated documentation for `Inspect` for a general rundown on
-the approaches and options available.
+    iex> Access.fetch(:foo, :bar)
+    ** (FunctionClauseError) no function clause matching in Access.fetch/2
 
-## v1.14.5 (2023-05-22)
+    The following arguments were given to Access.fetch/2:
 
-This release contains fixes for Erlang/OTP 26.
+        # 1
+        :foo
 
-### Bug fixes
+        # 2
+        :bar
 
-#### Elixir
+    Attempted function clauses (showing 5 out of 5):
 
-  * [CLI] Fix a bug where stdout would block when there was no attached terminal on Windows when running on Erlang/OTP 26
+        def fetch(-%struct{} = container-, key)
+        def fetch(map, key) when -is_map(map)-
+        def fetch(list, key) when -is_list(list)- and is_atom(key)
+        def fetch(list, key) when -is_list(list)-
+        def fetch(-nil-, _key)
 
-#### Mix
+    (elixir) lib/access.ex:261: Access.fetch/2
 
-  * [Mix] Properly set SSL configuration for Mix downloads when running on Erlang/OTP 26
+In the example above, an argument that did not match or guard that did not evaluate to true are shown between `-`. If the terminal supports ANSI coloring, they are wrapped in red instead of the `-` character.
 
-## v1.14.4 (2023-04-03)
+Since blaming an exception can be expensive, `Exception.blame/3` must be used exclusively in debugging situations. It is not advised to apply it to production components such as a Logger. This feature has been integrated into the compiler, the command line, ExUnit and IEx.
 
-This release adds basic support for Erlang/OTP 26. When migrating
-to Erlang/OTP 26, keep it mind it changes how maps are stored
-internally and they will be printed and traversed in a different
-order (note maps never provided a guarantee of their order).
-To aid migration, this release adds `:sort_maps` to `inspect`
-custom options, in case you want to sort them before inspection:
+This feature also requires Erlang/OTP 20+.
 
-    inspect(map, custom_options: [sort_maps: true])
+## Streamlined child specs
 
-### Enhancements
+Elixir v1.5 streamlines how supervisors are defined and used in Elixir. Elixir now allows child specifications, which specify how a child process is supervised, to be defined in modules. In previous versions, a project using Phoenix would write:
 
-#### Elixir
+    import Supervisor.Spec
 
-  * [Inspect] Add `:sort_maps` to `Inspect.Opts.custom_options`
+    children = [
+      supervisor(MyApp.Repo, []),
+      supervisor(MyApp.Endpoint, [])
+    ]
 
-#### IEx
+    Supervisor.start_link(children, strategy: :one_for_one)
 
-  * [IEx] Support shell history in Erlang/OTP 26+
+In Elixir v1.5, one might do:
 
-#### Mix
+    children = [
+      MyApp.Repo,
+      MyApp.Endpoint
+    ]
 
-  * [mix compile.elixir] Optimize application tracer
+    Supervisor.start_link(children, strategy: :one_for_one)
 
-### Bug fixes
+The above works by calling the `child_spec/1` function on the given modules.
 
-#### Elixir
+This new approach allows `MyApp.Repo` and `MyApp.Endpoint` to control how they run under a supervisor. This reduces the chances of mistakes being made, such as starting an Ecto repository as a worker or forgetting to declare that tasks are temporary in a supervision tree.
 
-  * [Code] Properly handle blocks with comments in all cases in `Code.quoted_to_string_with_comments/2`
-  * [Kernel] Fix `debug_info/4` when returning core_v1
-  * [Kernel] Store complete path on `quote keep: true` to avoid invalid stacktraces
-  * [Kernel] Fix column count when tokenizing escaped interpolations
-  * [Stream] Fix `Stream.zip/1` hanging on empty list
+If it is necessary to configure any of the children, such can be done by passing a tuple instead of an atom:
 
-#### Mix
+    children = [
+      {MyApp.Repo, url: "ecto://localhost:4567/my_dev"},
+      MyApp.Endpoint
+    ]
 
-  * [mix format] Don't call formatter on directories
+The modules `Agent`, `Registry`, `Task`, and `Task.Supervisor` have been updated to include a `child_spec/1` function, allowing them to be used directly in a supervision tree similar to the examples above. `use Agent`, `use GenServer`, `use Supervisor`, and `use Task` have also been updated to automatically define an overridable `child_spec/1` function.
 
-## v1.14.3 (2023-01-14)
+Finally, child specifications are now provided as maps (data-structures) instead of the previous `Supervisor.Spec.worker/3` and `Supervisor.Spec.supervisor/3` APIs. This behaviour also aligns with how supervisors are configured in Erlang/OTP 18+. See the updated `Supervisor` docs for more information, as well as the new `Supervisor.init/2` and `Supervisor.child_spec/2` functions.
+
+## @impl
+
+This release also allows developers to mark which functions in a given module are an implementation of a callback. For example, when using the [Plug](https://github.com/elixir-lang/plug) project, one needs to implement both `init/1` and `call/2` when writing a Plug:
+
+    defmodule MyApp do
+      @behaviour Plug
+
+      def init(_opts) do
+        opts
+      end
+
+      def call(conn, _opts) do
+        Plug.Conn.send_resp(conn, 200, "hello world")
+      end
+    end
+
+The problem with the approach above is that, once more and more functions are added to the `MyApp` module, it becomes increasingly harder to know the purposes of the `init/1` and `call/2` functions. For example, for a developer unfamiliar with Plug, are those functions part of the `MyApp` API or are they implementations of a given callback?
+
+Elixir v1.5 introduces the `@impl` attribute, which allows us to mark that certain functions are implementation of callbacks:
+
+    defmodule MyApp do
+      @behaviour Plug
+
+      @impl true
+      def init(_opts) do
+        opts
+      end
+
+      @impl true
+      def call(conn, _opts) do
+        Plug.Conn.send_resp(conn, 200, "hello world")
+      end
+    end
+
+You may even use `@impl Plug` if you want to explicitly document which behaviour defines the callback you are implementing.
+
+Overall, using `@impl` has the following advantages:
+
+  * Readability of the code is increased, as it is now clear which functions are part of your API and which ones are callback implementations. To reinforce this idea, `@impl true` automatically marks the function as `@doc false`, disabling documentation unless `@doc` is explicitly set
+
+  * If you define `@impl` before a function that is not a callback, Elixir will error. This is useful in case of typos or in case the behaviour definition changes (such as a new major version of a library you depend on is released)
+
+  * If you use `@impl` in one implementation, Elixir will force you to declare `@impl` for all other implementations in the same module, keeping your modules consistent
+
+## Calendar improvements
+
+This release brings further improvements to Calendar types. It adds arithmetic and others functions to `Time`, `Date`, `NaiveDateTime` and `Datetime` as well as conversion between different calendars.
+
+## v1.5.0-rc.2 (2017-07-20)
 
 ### 1. Enhancements
 
 #### Elixir
 
-  * [Kernel] Speed up loading of runtime modules in the parallel compiler
-  * [Range] Optimize range membership implementation
+  * [Calendar] Move calendar from `rata_die` to `iso_days`
+  * [Registry] Introduce `Registry.unregister_match/4`
+  * [String] Optimise binary pattern matching in `String.Break`
 
-#### ExUnit
+#### IEx
 
-  * [ExUnit] Return values from running doctests and make their order consistent
+  * [IEx.Helpers] Allow `__FILE__` and `__LINE__` customization in `IEx.Helpers.open/1`
 
 ### 2. Bug fixes
 
 #### Elixir
 
-  * [Calendar] Fix handling of negative years in `Calendar.strftime/2`
-  * [DateTime] Consistently merge precision of subsecond operations (the bug was that subsecond precision was lost in functions like `DateTime.add/3`)
-  * [Exception] Improve blaming of FunctionClauseError with `is_struct/2` guards
-  * [Kernel] Fix invalid variable scoping in `defguard` expansion
-  * [Kernel] Do not warn on captured underscored vars from `defmodule`
-  * [Kernel] Do not crash for missing line info on type warnings
-  * [NaiveDateTime] Consistently merge precision of subsecond operations (the bug was that subsecond precision was lost in functions like `NaiveDateTime.add/3`)
-  * [Macro] Fix `Macro.to_string/1` for large negative integers
-  * [Macro] Properly type and escape expansion of `__ENV__` in macros
-  * [Path] Make sure `Path.wildcard/2` expands `..` symlinks accordingly
-  * [Range] Address corner cases in `Range.disjoint?/2` implementation
-  * [Time] Consistently merge precision of subsecond operations (the bug was that subsecond precision was lost in functions like `Time.add/3`)
+  * [File] Ensure recursive file operations raise on paths with null bytes
+  * [Kernel] Bring the `e in _` syntax back to try/rescue (regression)
+  * [Kernel] Do not use named ETS tables during module definition (regression)
+  * [Path] Ensure recursive path operations raise on paths with null bytes
+  * [Registry] Ensure `Registry.match/4` works with `:_` as key
+  * [Stream] Fix regression in `Stream.chunk/4` (regression)
 
-#### ExUnit
+#### Mix
 
-  * [ExUnit.DocTest] Remove unnecessary literal quotes from error message on reports
+  * [mix compile.protocols] Do not raise when consolidating a protocol that was converted into a module
+  * [mix compile.erlang] Properly track `-compile` module attribute when specified as a list
 
-## v1.14.2 (2022-11-11)
+## v1.5.0-rc.1 (2017-07-12)
 
 ### 1. Enhancements
 
 #### Elixir
 
-  * [Code] Add `Code.eval_quoted_with_env/4` with support for the `:prune_binding` option
+  * [Base] Optimise Base encode/decode
+  * [Calendar] Implement Inspect for DateTime with Calendar.ISO
+  * [Enum] Introduce `Enum.chunk_every/2` and `Enum.chunk_every/4` with a more explicit API than `Enum.chunk/2` and `Enum.chunk/4`
+  * [Kernel] Cache the AST on definitions. This speeds up the compilation time from 10% to 15% measured across different projects
+  * [Kernel] Improve compiler error message on invalid patterns and guards
+  * [Stream] Introduce `Stream.chunk_every/2` and `Stream.chunk_every/4` with a more explicit API than `Stream.chunk/2` and `Stream.chunk/4`
 
-#### ExUnit
+#### IEx
 
-  * [ExUnit.Case] Allow test cases to not be registered on use
-  * [ExUnit.DocTest] Include `:doctest` and `:doctest_line` as meta tags
-  * [ExUnit.Formatter] Expose `ExUnit.Formatter.format_assertion_diff/4`
-
-#### Mix
-
-  * [Mix] `Mix.install/2` accepts atoms as paths
+  * [IEx.Helpers] Add `break!/2`, `break!/4`, `breaks/0`, `continue/0`, `open/0`, `remove_breaks/0`, `remove_breaks/1`, `reset_break/1`, `reset_break/3` and `whereami/1` for code debugging
+  * [IEx.Helpers] No longer emit warnings for IEx commands without parentheses
+  * [IEx.Helpers] Add `runtime_info/0` for printing runtime system information
+  * [IEx.Helpers] Add `open/1` to open the source of a given module/function in your editor
 
 ### 2. Bug fixes
 
 #### Elixir
 
-  * [Code.Formatter] Fix `size*unit` shortcut in bitstring
-  * [Kernel] Generate unique variables for macro expansion of `defguard`
-  * [Protocol] Expand `:for` in protocols with the appropriate env
+  * [Calendar] Return `{:error, :invalid_time}` for wrong precision instead of crashing
+  * [Enum] Rename `Enum.chunk_by/4` to `Enum.chunk_while/4` (`chunk_by/4` was only part of 1.5.0-rc.0) (regression)
+  * [Enumerable] Raise `Protocol.UndefinedError` on bad functions in Enumerable implementation
+  * [Inspect] Do not use colors when inspecting error messages
+  * [Kernel] Do not warn false positives about unused variables on rescue (regression)
+  * [Kernel] Ensure `do` clause in `with` is tail call optimizable
+  * [Protocol] Do not lose source compile info on protocol consolidation
+  * [Stream] Fix stream cycle over empty enumerable
+  * [Stream] Rename `Stream.chunk_by/4` to `Stream.chunk_while/4` (`chunk_by/4` was only part of 1.5.0-rc.0) (regression)
+  * [StringIO] Fix encoding and performance issues in `StringIO.get_until`
 
 #### ExUnit
 
-  * [ExUnit] Do not run duplicate cases on `ExUnit.run/1`
+  * [ExUnit] Load ExUnit configuration as late as possible (regression)
 
-#### Mix
-
-  * [mix test] Ensure proper error message when there is no test directory
-
-## v1.14.1 (2022-10-10)
+## v1.5.0-rc.0 (2017-06-25)
 
 ### 1. Enhancements
 
 #### Elixir
 
-  * [Kernel] Perform partial expansion of literals in module attributes
-  * [Kernel] Do not add compile-time dependencies for literals as defaults in `Application.compile_env/3` inside module attributes
-  * [Macro] Add `Macro.expand_literals/2` and `Macro.expand_literals/3`
-  * [System] Add `:close_stdin` to `System.shell/2`
-
-#### Mix
-
-  * [mix test] Accept `--all-warnings` option
-
-## 2. Bug fixes
-
-#### Elixir
-
-  * [Kernel] Fix misleading warning when `:uniq` is given in `for` comprehensions and the result is unused
-  * [Kernel] Improve error message for when there is a conflicting struct and ignoring module conflict
-  * [Kernel] Do not delete `@enforce_keys` attribute after `defstruct` declaration
-  * [Kernel] Do not crash the checker on modules with missing `:debug_info` chunk
-  * [Macro] Fix error in `Macro.to_string/2` when converting an AST with `:erlang.binary_to_atom/2`
-  * [String] Fix `String.split/3` and `String.next_grapheme/1` returning invalid results on invalid UTF-8 encoding
-  * [System] Do not close stdin by default in `System.shell/2`
-  * [URI] Do not return `uri.port` as `:undefined` in certain cases in `URI.new/1`
+  * [Access] Optimize Access.get/2
+  * [Calendar] Limit `Calendar.ISO` up to year 10000
+  * [Calendar] Add Rata Die format for conversions between Calendars and `Date.convert/2`, `Time.convert/2`, `NaiveDateTime.convert/2` and `DateTime.convert/2` (as well as bang variants)
+  * [Calendar] Add `:calendar` field to `Time` struct
+  * [Calendar] Add `Time.diff/3`, `Date.add/2`, `Date.diff/2`, `DateTime.diff/3`
+  * [Calendar] Add `Date.range/2`
+  * [Calendar] Add `Date.new/4`, `DateTime.utc_now/1`, `NaiveDateTime.new/8` and `Time.new/5` that allow specifing calendar
+  * [Enum] Add `Enum.chunk_by/4` and `Stream.chunk_by/4`
+  * [Exception] Add `Exception.blame/3` that adds metadata to exceptions
+  * [File] Add `File.read_link/1` and `File.read_link!/1`
+  * [File] Introduce `:trim_bom` option for `File.stream!/2`
+  * [Inspect] Add `:printable_limit` to control the limit of printable structures
+  * [Integer] Add `Integer.gcd/2`
+  * [Kernel] Add `left not in right` to check that the left side is not in the enumerable on the right
+  * [Kernel] Use the new `debug_info` chunk in OTP 20. This provides a mechanism for tools to retrieve the Elixir AST from beam files
+  * [Kernel] `defoverridable/1` accepts a module name as argument and marks all callbacks as overridable
+  * [Kernel] Allow non-quoted Unicode atoms and variables according to Unicode Annex #31 (see Unicode Syntax document)
+  * [Kernel] Warn when a `:__struct__` key is used when building/updating structs
+  * [Keyword] Add `replace/3` and `replace!/3` for replacing an existing key
+  * [List] `List.starts_with?/2`
+  * [Macro] Introduce `Macro.generate_arguments/2`
+  * [Map] Optimize `Map.merge/3` by choosing merging direction
+  * [Map] Add `replace/3` and `replace!/3` for replacing an existing key
+  * [Map] Raise `BadMapError` in `Map.equal?/2` when either of the two arguments is not a map
+  * [MapSet] Reduce `MapSet` size when serialized to approximately half
+  * [Process] Add `Process.cancel_timer/2`
+  * [Protocol] Show available implementations on `Protocol.UndefinedError` if the protocol has been consolidated
+  * [Registry] Support ETS guard conditions in `Registry.match/3`
+  * [Registry] Support `parallel: true` in `Registry.dispatch/3`
+  * [Supervisor] Add `Supervisor.init/2` and `Supervisor.child_spec/2`
+  * [Supervisor] Allow `module` and `{module, arg}` to be given to `Supervisor.start_link/2` and invoke `module.child_spec(arg)` on each argument
+  * [Task] Support `:on_timeout` in `Task.async_stream` to control how tasks are terminated
+  * [Task] Add `ordered: false` support to `Task.async_stream`
 
 #### ExUnit
 
-  * [ExUnit.DocTest] Do not crash when both `:moduledoc` and functions are specified in `:only`
+  * [ExUnit] Show code snippet from test source file in case of test errors
+  * [ExUnit] Use `Exception.blame/3` when formatting test errors
+  * [ExUnit] Make `assert_raise/2` fail if the underlying exception has a broken `message/1` implementation
+  * [ExUnit] Add `start_supervised/2` and `stop_supervised/1` to ExUnit. Processes started by this function are automatically shut down when the test exits
 
 #### IEx
 
-  * [CLI] Fix invalid argument handling when `--no-pry` is given
-
-#### Mix
-
-  * [mix format] Do not cache inputs from `.formatter.exs` so they are properly re-evaluted on every call
-
-## v1.14.0 (2022-09-01)
-
-### 1. Enhancements
-
-#### EEx
-
-  * [EEx] Support multi-line comments to EEx via `<%!-- --%>`
-  * [EEx] Add `EEx.tokenize/2`
-
-#### Elixir
-
-  * [Access] Add `Access.slice/1`
-  * [Application] Add `Application.compile_env/4` and `Application.compile_env!/3` to read the compile-time environment inside macros
-  * [Calendar] Support ISO8601 basic format parsing with `DateTime.from_iso8601/2`
-  * [Calendar] Add `day`/`hour`/`minute` on `add`/`diff` across different calendar modules
-  * [Code] Add `:normalize_bitstring_modifiers` to `Code.format_string!/2`
-  * [Code] Emit deprecation and type warnings for invalid options in on `Code.compile_string/2` and `Code.compile_quoted/2`
-  * [Code] Warn if an outdated lexical tracker is given on eval
-  * [Code] Add `Code.env_for_eval/1` and `Code.eval_quoted_with_env/3`
-  * [Code] Improve stacktraces from eval operations on Erlang/OTP 25+
-  * [Code.Fragment] Add support for `__MODULE__` in several functions
-  * [Code.Fragment] Support surround and context suggestions across multiple lines
-  * [Enum] Allow slicing with steps in `Enum.slice/2`
-  * [File] Support `dereference_symlinks: true` in `File.cp/3` and `File.cp_r/3`
-  * [Float] Do not show floats in scientific notation if below `1.0e16` and the fractional value is precisely zero
-  * [Float] Add `Float.min_finite/0` and `Float.max_finite/0`
-  * [Inspect] Improve error reporting when there is a faulty implementation of the `Inspect` protocol
-  * [Inspect] Allow `:optional` when deriving the Inspect protocol for hiding fields that match their default value
-  * [Inspect] Inspect struct fields in the order they are declared in `defstruct`
-  * [Inspect] Use expression-based inspection for `Date.Range`, `MapSet`, and `Version.Requirement`
-  * [IO] Support `Macro.Env` and keywords as stacktrace definitions in `IO.warn/2`
-  * [IO] Add `IO.ANSI.syntax_colors/0` and related configuration to be shared across IEx and `dbg`
-  * [Kernel] Add new `dbg/0-2` macro
-  * [Kernel] Allow any guard expression as the size of a bitstring in a pattern match
-  * [Kernel] Allow composite types with pins as the map key in a pattern match
-  * [Kernel] Print escaped version of control chars when they show up as unexpected tokens
-  * [Kernel] Warn on confusable non-ASCII identifiers
-  * [Kernel] Add `..` as a nullary operator that returns `0..-1//1`
-  * [Kernel] Implement Unicode Technical Standard #39 recommendations. In particular, we warn for confusable scripts and restrict identifiers to single-scripts or highly restrictive mixed-scripts
-  * [Kernel] Automatically perform NFC conversion of identifiers
-  * [Kernel] Add `binary_slice/2` and `binary_slice/3`
-  * [Kernel] Lazily expand module attributes to avoid compile-time deps
-  * [Kernel] Automatically cascade `generated: true` annotations on macro expansion
-  * [Keyword] Add `Keyword.from_keys/2` and `Keyword.replace_lazy/3`
-  * [List] Add `List.keysort/3` with support for a `sorter` function
-  * [Macro] Add `Macro.classify_atom/1` and `Macro.inspect_atom/2`
-  * [Macro] Add `Macro.path/2`
-  * [Macro.Env] Add `Macro.Env.prune_compile_info/1`
-  * [Map] Add `Map.from_keys/2` and `Map.replace_lazy/3`
-  * [MapSet] Add `MapSet.filter/2`, `MapSet.reject/2`, and `MapSet.symmetric_difference/2`
-  * [Node] Add `Node.spawn_monitor/2` and `Node.spawn_monitor/4`
-  * [Module] Support new `@after_verify` attribute for executing code whenever a module is verified
-  * [PartitionSupervisor] Add `PartitionSupervisor` that starts multiple isolated partitions of the same child for scalability
-  * [Path] Add `Path.safe_relative/1` and `Path.safe_relative_to/2`
-  * [Registry] Add `Registry.count_select/2`
-  * [Stream] Add `Stream.duplicate/2` and `Stream.transform/5`
-  * [String] Support empty lookup lists in `String.replace/3`, `String.split/3`, and `String.splitter/3`
-  * [String] Allow slicing with steps in `String.slice/2`
-  * [Task] Add `:zip_input_on_exit` option to `Task.async_stream/3`
-  * [Task] Store `:mfa` in the `Task` struct for reflection purposes
-  * [URI] Add `URI.append_query/2`
-  * [Version] Add `Version.to_string/1`
-  * [Version] Colorize `Version.Requirement` source in the `Inspect` protocol
-
-#### ExUnit
-
-  * [ExUnit] Add `ExUnit.Callbacks.start_link_supervised!/2`
-  * [ExUnit] Add `ExUnit.run/1` to rerun test modules
-  * [ExUnit] Colorize summary in yellow with message when all tests are excluded
-  * [ExUnit] Display friendly error when test name is too long
-
-#### IEx
-
-  * [IEx] Evaluate `--dot-iex` line by line
-  * [IEx] Add line-by-line evaluation of IEx breakpoints
-  * [IEx.Autocomplete] Autocomplete bitstrings modifiers (after `::` inside `<<...>>`)
-  * [IEx.Helpers] Allow an atom to be given to `pid/1`
-  * [IEx.Helpers] Support sigils in `h/1`
+  * [IEx.Autocomplete] Support autocompletion of variable names
+  * [IEx.Autocomplete] Support autocompletion of functions imported using `import Mod, only: [...]`
+  * [IEx.Evaluator] Use `Exception.blame/3` when showing errors in the terminal
+  * [IEx.Helpers] Add `exports/1` IEx helper to list all exports in a module
+  * [IEx.Info] Implement `IEx.Info` protocol for calendar types
 
 #### Logger
 
-  * [Logger] Add `Logger.put_process_level/2`
+  * [Logger] Add `metadata: :all` configuration to log all metadata
 
 #### Mix
 
-  * [Mix] Add `:config_path` and `:lockfile` options to `Mix.install/2`
-  * [mix compile] Add `--no-optional-deps` to skip optional dependencies to test compilation works without optional dependencies
-  * [mix compile] Include column information on error diagnostics when possible
-  * [mix deps] `Mix.Dep.Converger` now tells which deps formed a cycle
-  * [mix do] Support `--app` option to restrict recursive tasks in umbrella projects
-  * [mix do] Allow using `+` as a task separator instead of comma
-  * [mix format] Support filename in `mix format -` when reading from stdin
-  * [mix format] Compile if `mix format` plugins are missing
-  * [mix new] Do not allow projects to be created with application names that conflict with multi-arg Erlang VM switches
-  * [mix profile] Return the return value of the profiled function
-  * [mix release] Make BEAM compression opt-in
-  * [mix release] Let `:runtime_config_path` accept `false` to skip the `config/runtime.exs`
-  * [mix test] Improve error message when suite fails due to coverage
-  * [mix test] Support `:test_elixirc_options` and default to not generating docs nor debug info chunk for tests
-  * [mix xref] Support `--group` flag in `mix xref graph`
+  * [mix compile.elixir] Add `--all-warnings` option to Elixir compiler that shows all warnings from the previous compilation (instead of just of the files being compiled)
+  * [mix escript.build] Strip debug information from escripts by default and add option `:strip_beam` which defaults to true
+  * [mix loadpaths] Ensure `--no-deps-check` do not trigger SCM callbacks (such as `git`)
+  * [mix local.hex] Add `--if-missing` flag to `local.hex` mix task
+  * [mix profile.cprof] Add `Mix.Tasks.Profile.Cprof` for count-based profiling
+  * [mix new] New styling for generated applications
 
 ### 2. Bug fixes
 
 #### Elixir
 
-  * [Calendar] Handle widths with "0" in them in `Calendar.strftime/3`
-  * [CLI] Improve errors on incorrect `--rpc-eval` usage
-  * [CLI] Return proper exit code on Windows
-  * [Code] Do not emit warnings when formatting code
-  * [Enum] Allow slices to overflow on both starting and ending positions
-  * [Kernel] Do not allow restricted characters in identifiers according to UTS39
-  * [Kernel] Define `__exception__` field as `true` when expanding exceptions in typespecs
-  * [Kernel] Warn if any of `True`, `False`, and `Nil` aliases are used
-  * [Kernel] Warn on underived `@derive` attributes
-  * [Kernel] Remove compile-time dependency from `defimpl :for`
-  * [Kernel] Track all arities on imported functions
-  * [Kernel] Fix equality in guards for dynamic ranges without steps
-  * [Module] Fix loop while unifying type variables
-  * [Protocol] Warn if a protocol has no definitions
-  * [Regex] Show list options when inspecting a Regex manually defined with `Regex.compile/2`
-  * [String] Allow slices to overflow on both starting and ending positions
-  * [System] Raise non-generic exception on missing env in `System.fetch_env!/1` to mirror map operations
+  * [File] Support `:ram`/`:raw` files in `File.copy/2`
+  * [Kernel] Support guards on anonymous functions of zero arity
+  * [Kernel] Fix compilation of maps used as maps keys inside matches
+  * [Module] `on_definition/6` callback receives body wrapped in a keyword list, such as `[do: body]`. This solves a bug where it was impossible to distinguish between a bodyless clause and a function that returns `nil`.
+  * [Record] Properly escape quoted expressions passed to `defrecord`
+  * [Regex] Fix `inspect/2` for regexes with `/` terminator in them
+  * [String] Consider Unicode non-characters valid according to the specification in `String.valid?/1`
 
 #### ExUnit
 
-  * [ExUnit] Do not crash when diffing unknown bindings in guards
-  * [ExUnit] Properly print diffs when comparing improper lists with strings at the tail position
-  * [ExUnit] Add short hash to `tmp_dir` in ExUnit to avoid test name collision
-  * [ExUnit] Do not store logs in the CLI formatter (this reduces memory usage for suites with `capture_log`)
-  * [ExUnit] Run `ExUnit.after_suite/1` callback even when no tests run
-  * [ExUnit] Fix scenario where `setup` with imported function from within `describe` failed to compile
+  * [ExUnit] Properly account failed tests when `setup_all` fails
 
 #### IEx
 
-  * [IEx] Disallow short-hand pipe after matches
-  * [IEx] Fix `exports/1` in IEx for long function names
+  * [IEx] Skip autocompletion of module names that are invalid without being quoted
+  * [IEx] Skip autocompletion of functions with default arguments with `@doc false`
+  * [IEx] Do not start oldshell alongside IEx
 
 #### Mix
 
-  * [mix compile.elixir] Fix `--warnings-as-errors` when used with `--all-warnings`
-  * [mix compile.elixir] Ensure semantic recompilation cascades to path dependencies
-  * [mix compile.elixir] Lock the compiler to avoid concurrent usage
-  * [mix format] Do not add new lines if the formatted file is empty
-  * [mix format] Properly compile dependencies on `mix format`
-  * [mix release] Only set `RELEASE_MODE` after `env.{sh,bat}` are executed
-  * [mix release] Allow application mode configuration to cascade to dependencies
-  * [mix xref] Do not emit already consolidated warnings during `mix xref trace`
-  * [Mix] Do not start apps with `runtime: false` on `Mix.install/2`
+  * [mix compile.elixir] Store multiple sources in case of module conflicts. This solves an issue where `_build` would get corrupted when compiling Elixir projects with module conflicts
+  * [mix compile.erlang] Do not silently discard Erlang compile errors
+  * [mix compile.protocols] Ensure protocol implementations do not "disappear" when switching between applications in umbrella projects by having separate consolidation paths per project
 
 ### 3. Soft deprecations (no warnings emitted)
 
 #### Elixir
 
-  * [File] Passing a callback as third argument to `File.cp/3` and `File.cp_r/3` is deprecated.
-    Instead pass the callback the `:on_conflict` key of a keyword list
+  * [Kernel] `not left in right` is soft-deprecated in favor of `left not in right`
 
-#### EEx
-
-  * [EEx] Using `<%# ... %>` for comments is deprecated. Please use `<% # ... %>` or the new multi-line comments with `<%!-- ... --%>`
-
-#### Logger
-
-  * [Logger] Deprecate `Logger.enable/1` and `Logger.disable/1` in favor of `Logger.put_process_level/2`
-
-#### Mix
-
-  * [mix cmd] The `--app` option in `mix cmd CMD` is deprecated in favor of the more efficient `mix do --app app cmd CMD`
-
-### 4. Hard deprecations
+### 4. Deprecations
 
 #### Elixir
 
-  * [Application] Calling `Application.get_env/3` and friends in the module body is now discouraged, use `Application.compile_env/3` instead
-  * [Bitwise] `use Bitwise` is deprecated, use `import Bitwise` instead
-  * [Bitwise] `~~~` is deprecated in favor of `bnot` for clarity
-  * [Kernel.ParallelCompiler] Returning a list or two-element tuple from `:each_cycle` is deprecated, return a `{:compile | :runtime, modules, warnings}` tuple instead
-  * [Kernel] Deprecate the operator `<|>` to avoid ambiguity with upcoming extended numerical operators
-  * [String] Deprecate passing a binary compiled pattern to `String.starts_with?/2`
+  * `Atom.to_char_list/1`, `Float.to_char_list/1`, `Integer.to_char_list/1`, `Integer.to_char_list/2`, `Kernel.to_char_list/1`, `List.Chars.to_char_list/1`, `String.to_char_list/1` have been deprecated in favor of their `to_charlist` version. This aligns with the naming conventions in both Erlang and Elixir
+  * [Enum] Deprecate `Enum.filter_map/3` in favor of `Enum.filter/2` + `Enum.map/2` or for-comprehensions
+  * [GenEvent] Deprecate `GenEvent` and provide alternatives in its docs
+  * [Kernel] Using `()` to mean `nil` is deprecated
+  * [Kernel] `:as_char_lists value` in `Inspect.Opts.t/0` type, in favor of `:as_charlists`
+  * [Kernel] `:char_lists` key in `Inspect.Opts.t/0` type, in favor of `:charlists`
+  * [Module] Using Erlang parse transforms via `@compile {:parse_transform, _}` is deprecated
+  * [Stream] Deprecate `Stream.filter_map/3` in favor of `Stream.filter/2` + `Stream.map/2`
+  * [String] `String.ljust/3` and `String.rjust/3` are deprecated in favor of `String.pad_leading/3` and `String.pad_trailing/3` with a binary padding
+  * [String] `String.strip/1` and `String.strip/2` are deprecated in favor of `String.trim/1` and `String.trim/2`
+  * [String] `String.lstrip/1` and `String.rstrip/1` are deprecated in favor of `String.trim_leading/1` and `String.trim_trailing/1`
+  * [String] `String.lstrip/2` and `String.rstrip/2` are deprecated in favor of `String.trim_leading/2` and `String.trim_trailing/2` with a binary as second argument
+  * [Typespec] `char_list/0` type is deprecated in favor of `charlist/0`
 
-#### Logger
+#### EEx
 
-  * [Logger] Deprecate `$levelpad` on message formatting
+  * [EEx] Deprecate `<%= ` in middle and end expressions, e.g.: `<%= else %>` and `<%= end %>`
 
-#### Mix
+## v1.4
 
-  * [Mix] `Mix.Tasks.Xref.calls/1` is deprecated in favor of compilation tracers
-
-### 5. Backwards incompatible changes
-
-#### Mix
-
-  * [mix local.rebar] Remove support for rebar2, which has not been updated in 5 years, and is no longer supported on recent Erlang/OTP versions
-
-## v1.13
-
-The CHANGELOG for v1.13 releases can be found [in the v1.13 branch](https://github.com/elixir-lang/elixir/blob/v1.13/CHANGELOG.md).
+The CHANGELOG for v1.4 releases can be found [in the v1.4 branch](https://github.com/elixir-lang/elixir/blob/v1.4/CHANGELOG.md).

CODE_OF_CONDUCT.md

@@ -13,23 +13,17 @@ The goal of the Code of Conduct is to specify a baseline standard of behavior so
 These are the values Elixir developers should aspire to:
 
   * Be friendly and welcoming
-  * Be kind
+  * Be patient
     * Remember that people have varying communication styles and that not everyone is using their native language. (Meaning and tone can be lost in translation.)
-    * Interpret the arguments of others in good faith, do not seek to disagree.
-    * When we do disagree, try to understand why.
   * Be thoughtful
     * Productive communication requires effort. Think about how your words will be interpreted.
     * Remember that sometimes it is best to refrain entirely from commenting.
   * Be respectful
     * In particular, respect differences of opinion. It is important that we resolve disagreements and differing views constructively.
-  * Be constructive
-    * Avoid derailing: stay on topic; if you want to talk about something else, start a new conversation.
-    * Avoid unconstructive criticism: don't merely decry the current state of affairs; offer — or at least solicit — suggestions as to how things may be improved.
-    * Avoid harsh words and stern tone: we are all aligned towards the well-being of the community and the progress of the ecosystem. Harsh words exclude, demotivate, and lead to unnecessary conflict.
-    * Avoid snarking (pithy, unproductive, sniping comments).
-    * Avoid microaggressions (brief and commonplace verbal, behavioral and environmental indignities that communicate hostile, derogatory or negative slights and insults towards a project, person or group).
-  * Be responsible
-    * What you say and do matters. Take responsibility for your words and actions, including their consequences, whether intended or otherwise.
+  * Avoid destructive behavior
+    * Derailing: stay on topic; if you want to talk about something else, start a new conversation.
+    * Unconstructive criticism: don't merely decry the current state of affairs; offer (or at least solicit) suggestions as to how things may be improved.
+    * Snarking (pithy, unproductive, sniping comments).
 
 The following actions are explicitly forbidden:
 
@@ -45,13 +39,13 @@ 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][2]** IRC channel on [Libera.Chat][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 block, remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct.
+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.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by emailing: elixir-lang-conduct@googlegroups.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. **All reports will be kept confidential**.
 
@@ -59,8 +53,4 @@ 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 (dated Sep/2021) and the Contributor Covenant (v1.4).
-
-[1]: https://github.com/elixir-lang/
-[2]: https://web.libera.chat/#elixir
-[3]: https://libera.chat/
+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.

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 & Erlang versions (elixir --version): 
+* 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,15 +1,10 @@
+REBAR ?= "$(CURDIR)/rebar"
 PREFIX ?= /usr/local
-TEST_FILES ?= "*_test.exs"
 SHARE_PREFIX ?= $(PREFIX)/share
-MAN_PREFIX ?= $(SHARE_PREFIX)/man
-CANONICAL := 1.14/
-CANONICAL ?= main/
-DOCS_FORMAT ?= html
-ELIXIRC := bin/elixirc --ignore-module-conflict $(ELIXIRC_OPTS)
+CANONICAL := v1.5/
+ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
 ERLC := erlc -I lib/elixir/include
-ERL_MAKE := if [ -n "$(ERLC_OPTS)" ]; then ERL_COMPILER_OPTIONS=$(ERLC_OPTS) erl -make; else erl -make; fi
 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
@@ -20,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 clean_residual_files 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 >= 23)])' -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 23.0 is required to build Elixir"; \
+		  echo "At least Erlang 18.0 is required to build Elixir"; \
 		  exit 1; \
-		fi
+		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)"
@@ -48,43 +45,32 @@ 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 -f 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
+# then mix and then compile EEx fully
 elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit logger eex iex
 
 stdlib: $(KERNEL) VERSION
@@ -93,20 +79,18 @@ $(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
 		echo "==> bootstrap (compile)"; \
 		$(ERL) -s elixir_compiler bootstrap -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 -f 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/security.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;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
@@ -128,39 +112,14 @@ install: compile
 	$(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) bin/elixir lib/elixir/diff.exs lib/elixir/ebin/ lib/elixir/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/diff.exs lib/eex/ebin/ lib/eex/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/diff.exs lib/ex_unit/ebin/ lib/ex_unit/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/diff.exs lib/iex/ebin/ lib/iex/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/diff.exs lib/logger/ebin/ lib/logger/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/diff.exs lib/mix/ebin/ lib/mix/tmp/ebin_reproducible/
-	$(Q) echo "Builds are reproducible"
+	$(MAKE) install_man
 
 clean:
+	cd lib/elixir && $(REBAR) clean
 	rm -rf ebin
 	rm -rf lib/*/ebin
-	rm -rf $(PARSER)
-	$(Q) "$(MAKE)" clean_residual_files
+	rm -f lib/elixir/src/elixir.app.src
+	$(Q) $(MAKE) clean_residual_files
 
 clean_elixir:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
@@ -173,47 +132,47 @@ clean_residual_files:
 	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 -rf lib/mix/test/fixtures/archive/ebin/
 	rm -f erl_crash.dump
-	$(Q) "$(MAKE)" clean_man
+	$(Q) $(MAKE) clean_man
 
 #==> Documentation tasks
 
 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}")
-COMPILE_DOCS = CANONICAL=$(CANONICAL) 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)
+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" -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/Deprecations.md" -e "lib/elixir/pages/Guards.md" -e "lib/elixir/pages/Naming Conventions.md" -e "lib/elixir/pages/Operators.md" -e "lib/elixir/pages/Syntax Reference.md" -e "lib/elixir/pages/Typespecs.md" -e "lib/elixir/pages/Unicode Syntax.md" -e "lib/elixir/pages/Writing Documentation.md")
 
 docs_eex: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (eex)"
 	$(Q) rm -rf doc/eex
-	$(call COMPILE_DOCS,EEx,eex,EEx,--config "lib/mix/docs.exs")
+	$(call COMPILE_DOCS,EEx,eex,EEx)
 
 docs_mix: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (mix)"
 	$(Q) rm -rf doc/mix
-	$(call COMPILE_DOCS,Mix,mix,Mix,--config "lib/mix/docs.exs")
+	$(call COMPILE_DOCS,Mix,mix,Mix)
 
 docs_iex: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (iex)"
 	$(Q) rm -rf doc/iex
-	$(call COMPILE_DOCS,IEx,iex,IEx,--config "lib/mix/docs.exs")
+	$(call COMPILE_DOCS,IEx,iex,IEx)
 
 docs_ex_unit: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (ex_unit)"
 	$(Q) rm -rf doc/ex_unit
-	$(call COMPILE_DOCS,ExUnit,ex_unit,ExUnit,--config "lib/mix/docs.exs")
+	$(call COMPILE_DOCS,ExUnit,ex_unit,ExUnit)
 
 docs_logger: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (logger)"
 	$(Q) rm -rf doc/logger
-	$(call COMPILE_DOCS,Logger,logger,Logger,--config "lib/mix/docs.exs")
+	$(call COMPILE_DOCS,Logger,logger,Logger)
 
 ../ex_doc/bin/ex_doc:
 	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
@@ -222,19 +181,20 @@ docs_logger: compile ../ex_doc/bin/ex_doc
 #==> Zip tasks
 
 Docs.zip: docs
-	rm -f Docs.zip
-	zip -9 -r Docs.zip CHANGELOG.md doc NOTICE LICENSE README.md
-	@ echo "Docs file created $(CURDIR)/Docs.zip"
+	rm -f 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.zip
-	zip -9 -r Precompiled.zip bin CHANGELOG.md lib/*/ebin lib/*/lib LICENSE Makefile man NOTICE README.md VERSION
-	@ echo "Precompiled file created $(CURDIR)/Precompiled.zip"
+	rm -f 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
 
 #==> Test tasks
 
-# If you modify this task, please update .cirrus.yml accordingly
-test: test_formatted test_erlang test_elixir
+test: test_erlang test_elixir
 
 test_windows: test test_taskkill
 
@@ -246,20 +206,6 @@ 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;
@@ -269,15 +215,15 @@ $(TEST_EBIN)/%.beam: $(TEST_ERL)/%.erl
 	$(Q) mkdir -p $(TEST_EBIN)
 	$(Q) $(ERLC) -o $(TEST_EBIN) $<
 
-test_elixir: test_stdlib test_ex_unit test_logger test_eex test_iex test_mix
+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
@@ -287,7 +233,7 @@ PLT = .elixir.plt
 
 $(PLT):
 	@ echo "==> Building PLT with Elixir's dependencies..."
-	$(Q) dialyzer --output_plt $(PLT) --build_plt --apps erts kernel stdlib compiler syntax_tools parsetools tools ssl inets crypto runtime_tools ftp tftp mnesia public_key asn1 sasl
+	$(Q) dialyzer --output_plt $(PLT) --build_plt --apps erts kernel stdlib compiler syntax_tools parsetools tools ssl inets
 
 clean_plt:
 	$(Q) rm -f $(PLT)
@@ -296,7 +242,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
 
@@ -304,13 +250,13 @@ 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
 
 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
 
@@ -321,9 +267,9 @@ clean_man:
 	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
-	"$(MAKE)" clean_man
+	$(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,24 +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
-Copyright 2021 The Elixir Team
-
-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,82 +1,18 @@
-<img src="https://github.com/elixir-lang/elixir-lang.github.com/raw/main/images/logo/logo.png#gh-light-mode-only" width="200" alt="Elixir">
-<img src="https://github.com/elixir-lang/elixir-lang.github.com/raw/main/images/logo/logo-dark.png#gh-dark-mode-only" width="200" alt="Elixir">
+![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
+=========
+[![Travis build](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master
+"Build Status")](https://travis-ci.org/elixir-lang/elixir)
+[![Windows build](https://ci.appveyor.com/api/projects/status/macwuxq7aiiv61g1?svg=true)](https://ci.appveyor.com/project/josevalim/elixir)
 
-[![CI](https://github.com/elixir-lang/elixir/workflows/CI/badge.svg?branch=main)](https://github.com/elixir-lang/elixir/actions?query=branch%3Amain+workflow%3ACI) [![Build status](https://api.cirrus-ci.com/github/elixir-lang/elixir.svg?branch=main)](https://cirrus-ci.com/github/elixir-lang/elixir)
 
-Elixir is a dynamic, functional language designed for building scalable
-and maintainable applications.
+Elixir is a dynamic, functional language designed for building scalable and maintainable applications.
 
 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**.
-
-## Issues tracker management
-
-All currently open bugs related to the Elixir repository are listed
-in the issues tracker. The Elixir team uses the issues tracker to focus
-on *actionable items*, including planned enhancements in the short- and
-medium-term. We also do our best to label entries for clarity and to ease
-collaboration.
-
-Our *actionable item policy* has some important consequences, such as:
-
-  * Proposing new features as well as request for support, help, and
-    guidance must be done in their own spaces, detailed next.
-
-  * Issues where we have identified to be outside of Elixir scope,
-    such as a bug upstream, will be closed (and requested to be moved
-    elsewhere if appropriate).
-
-  * We actively close unrelated and non-actionable issues to keep the
-    issues tracker tidy. However, we may get things wrong from time to
-    time, so we are glad to revisit issues and reopen if necessary.
-
-Keep the tone positive and be kind! For more information, see the
-[Code of Conduct][1].
-
-### Proposing new features
-
-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].
-Features and bug fixes that have already been merged and will be included
-in the next release are then "closed" and added to the [changelog][7].
-
-### Discussions, support, and help
-
-For general discussions, support, and help, please use many of the community
-spaces [listed on the sidebar of the Elixir website](https://elixir-lang.org/),
-such as forums, chat platforms, etc, where the wider community will be available
-to help you.
+[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).
-However, if you want to contribute to Elixir, you will need to compile from source.
-
-First, [install Erlang](https://elixir-lang.org/install.html#installing-erlang).
-After that, 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
@@ -88,37 +24,53 @@ make clean test
 [this article includes important notes for compiling Elixir from source
 on Windows](https://github.com/elixir-lang/elixir/wiki/Windows).
 
-In case you want to use this Elixir version as your system version,
-you need to add the `bin` directory to [your PATH environment variable](https://elixir-lang.org/install.html#setting-path-environment-variable).
-
 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 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 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 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.
+
+## Bug reports
+
+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 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 just changed something in the Elixir's standard
+library, you can run only that portion through `make test_stdlib`, as
+`test_elixir` also runs tests for the other projects (EEx, ExUnit, etc.).
 
-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:
 
@@ -127,42 +79,50 @@ bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
 bin/elixir lib/elixir/test/elixir/string_test.exs
 ```
 
-You can also use the `LINE` env var to run a single test:
-
-```sh
-LINE=123 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
-`make test`.
-
-If your contribution fails during the bootstrapping of the language,
-you can rebuild the language from scratch with:
+If your contribution fails the build during the bootstrapping of the language,
+you can reproduce it locally by deleting all of Elixir beam files and compiling
+again:
 
 ```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](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml).
-More tasks can be found by reading the [Makefile](Makefile).
+Or to rebuild everything from scratch without running tests:
+
+```sh
+make clean compile
+```
+
+More tasks can be found by reading the [Makefile](./Makefile).
+
+After your changes are done, please remember to run the full suite with
+`make test`.
+
+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
 
@@ -170,23 +130,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 the "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
 
@@ -195,47 +147,37 @@ to be installed and built alongside Elixir:
 
 ```sh
 # After cloning and compiling Elixir, in its parent directory:
-git clone https://github.com/elixir-lang/ex_doc.git
-cd ex_doc && ../elixir/bin/mix do deps.get + compile
+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,
+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](https://hexdocs.pm/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]
-  * **[#elixir][4]** on [Libera.Chat][5] IRC
+  * [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://web.libera.chat/#elixir
-  [5]: https://libera.chat
-  [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
+  [4]: https://webchat.freenode.net/?channels=#elixir-lang
+  [5]: http://www.freenode.net
+  [6]: http://elixir-lang.org/docs.html
+  [7]: CODE_OF_CONDUCT.md
 
 ## License
 
-"Elixir" and the Elixir logo are registered trademarks of The Elixir Team.
+"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,49 +1,35 @@
 # 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, bin/elixir and bin/elixir.bat
+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. If a new `vMAJOR.MINOR`, replace "master" with "vVERSION" in the "Deprecations" page and commit
 
-5. Commit changes above with title "Release vVERSION", generate a new tag, and push it
+5. If a new `vMAJOR.MINOR`, create a new branch "vMAJOR.MINOR" and set `CANONICAL=` in Makefile
 
-6. Wait until GitHub Actions publish artifacts to the draft release and the CI is green
+6. Commit changes above with title "Release vVERSION" and generate new tag
 
-7. Copy the relevant bits from /CHANGELOG.md to the GitHub release and publish it
+7. Run `make clean test` to ensure all tests pass from scratch and the CI is green
 
-8. Add the release to `elixir.csv` with the minimum supported OTP version (all releases), update `erlang.csv` to the latest supported OTP version, and `_data/elixir-versions.yml` (except for RCs) files in `elixir-lang/elixir-lang.github.com`
+8. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
 
-## Creating a new vMAJOR.MINOR branch
+9. Push branch and the new tag
 
-### In the new branch
+10. Publish new zips with `make zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
 
-1. Set `CANONICAL=` in /Makefile
+11. Add the release to `elixir.csv` and `_data/elixir-versions.yml` files in `elixir-lang/elixir-lang.github.com`
 
-2. Update tables in /SECURITY.md and "Compatibility and Deprecations"
+12. After a new `vMAJOR.MINOR`, move back to master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vMAJOR.MINOR+1"
 
-3. Commit "Branch out vMAJOR.MINOR"
+## Places where version is mentioned
 
-### Back in main
-
-1. Bump /VERSION file, bin/elixir and bin/elixir.bat
-
-2. Start new /CHANGELOG.md
-
-3. Update tables in /SECURITY.md and in "Compatibility and Deprecations"
-
-4. Commit "Start vMAJOR.MINOR+1"
-
-## Changing supported Erlang/OTP versions
-
-1. Update the table in Compatibility and Deprecations
-
-2. Update `otp_release` checks in /Makefile and `/lib/elixir/src/elixir.erl`
-
-3. Update CI workflows in `/.cirrus.yml`, `/.github/workflows/ci.yml`, and `/.github/workflows/releases.yml`
-
-4. Remove `otp_release` version checks that are no longer needed
+* VERSION
+* CHANGELOG.md
+* src/elixir.app.src (not lib/elixir/src/elixir.app.src)

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.14           | Bug fixes and security patches
-1.13           | Security patches only
-1.12           | Security patches only
-1.11           | Security patches only
-1.10           | 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.
-
-Security notifications [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.14.5
+1.5.0-rc.2

bin/elixir

@@ -1,62 +1,31 @@
 #!/bin/sh
-set -e
+if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+  echo "Usage: `basename $0` [options] [.exs file] [data]
 
-ELIXIR_VERSION=1.14.5
+  -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 (*)
 
-if [ $# -eq 0 ] || { [ $# -eq 1 ] && { [ "$1" = "--help" ] || [ "$1" = "-h" ]; }; }; then
-  cat <<USAGE >&2
-Usage: $(basename "$0") [options] [.exs file] [data]
+  --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 (*)
+  --help, -h                  Prints this message and exits
+  --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
+  --version, -v               Prints Elixir version and exits
+  --werl                      Uses Erlang's Windows shell GUI (Windows only)
 
-## General options
-
-  -e "COMMAND"                 Evaluates the given command (*)
-  -h, --help                   Prints this message (standalone)
-  -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 Erlang/OTP and Elixir versions (standalone)
-
-  --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
-  --short-version              Prints Elixir version (standalone)
-  --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.
-** Standalone options can't be combined with other options.
-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
 
@@ -66,152 +35,70 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 
-if [ $# -eq 1 ] && [ "$1" = "--short-version" ]; then
-  echo "$ELIXIR_VERSION"
-  exit 0
-fi
-
-# Stores static Erlang arguments and --erl (which is passed as is)
-ERL=""
-
-# Stores erl arguments preserving spaces/quotes (mimics an array)
-erl_set () {
-  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
-  # S counts to be shifted, C counts to be copied
-  S=0
-  C=0
-  case "$1" in
+while [ $I -le $# ]; do
+  S=1
+  eval "PEEK=\${$I}"
+  case "$PEEK" in
     +iex)
-        C=1
         MODE="iex"
         ;;
     +elixirc)
-        C=1
         MODE="elixirc"
         ;;
-    -v|--no-halt|--no-pry)
-        C=1
+    -v|--compile|--no-halt)
         ;;
-    -e|-r|-pr|-pa|-pz|--app|--eval|--remsh|--dot-iex)
-        C=2
+    -e|-r|-pr|-pa|-pz|--remsh|--app)
+        S=2
         ;;
-    --rpc-eval)
-        C=3
+    --detached|--hidden)
+        ERL="$ERL `echo $PEEK | cut -c 2-`"
         ;;
-    --hidden)
-        S=1
-        ERL="$ERL -hidden"
+    --cookie)
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL -setcookie "$VAL""
+        ;;
+    --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_set "-setcookie"
-        erl_set "$2"
-        ;;
-    --sname|--name)
-        S=2
-        erl_set "$(echo "$1" | cut -c 2-)"
-        erl_set "$2"
-        ;;
-    --erl-config)
-        S=2
-        erl_set "-config"
-        erl_set "$2"
-        ;;
-    --vm-args)
-        S=2
-        erl_set "-args_file"
-        erl_set "$2"
-        ;;
-    --boot)
-        S=2
-        erl_set "-boot"
-        erl_set "$2"
-        ;;
-    --boot-var)
-        S=3
-        erl_set "-boot_var"
-        erl_set "$2"
-        erl_set "$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)
-        S=1
-        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
-
-  while [ $I -le $LENGTH ] && [ $C -gt 0 ]; do
-    C=$((C - 1))
-    I=$((I + 1))
-    set -- "$@" "$1"
-    shift
-  done
-
-  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")
@@ -220,30 +107,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
 
-# One MAY change ERTS_BIN= but you MUST NOT change
-# ERTS_BIN=$ERTS_BIN as it is handled by Elixir releases.
-ERTS_BIN=
-ERTS_BIN="$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,193 +1,114 @@
 @if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
-
-set ELIXIR_VERSION=1.14.5
-
-setlocal enabledelayedexpansion
-if    ""%1""==""""                if ""%2""=="""" goto documentation
-if /I ""%1""==""--help""          if ""%2""=="""" goto documentation
-if /I ""%1""==""-h""              if ""%2""=="""" goto documentation
-if /I ""%1""==""/h""              if ""%2""=="""" goto documentation
-if    ""%1""==""/?""              if ""%2""=="""" goto documentation
-if /I ""%1""==""--short-version"" if ""%2""=="""" goto shortversion
+setlocal
+if    ""%1""==""""       goto documentation
+if /I ""%1""==""--help"" goto documentation
+if /I ""%1""==""-h""     goto documentation
+if /I ""%1""==""/h""     goto documentation
+if    ""%1""==""/?""     goto documentation
 goto parseopts
 
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo ## General options
+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 (standalone)
-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 Erlang/OTP and Elixir versions (standalone)
+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   --help, -h                  Prints this message and exits
+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   --version, -v               Prints Elixir version and exits
+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   --short-version              Prints Elixir version (standalone)
-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 ** Standalone options can't be combined with other options.
-goto end
-
-:shortversion
-echo !ELIXIR_VERSION!
+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=
-set ERTS_BIN=!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"
-  if not defined VAR (set VAR= )
-  set parsElixir=!parsElixir! -e "!VAR:"=\"!"
-  shift
-  goto startloop
-)
-if ""==!par:--eval=! (
-  set "VAR=%~1"
-  if not defined VAR (set VAR= )
-  set parsElixir=!parsElixir! --eval "!VAR:"=\"!"
-  shift
-  goto startloop
-)
-if ""==!par:--rpc-eval=! (
-  set "VAR=%~2"
-  if not defined VAR (set VAR= )
-  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:--version=!   (set "parsElixir=!parsElixir! --version" && 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)
-if ""==!par:--no-pry=!    (set "parsElixir=!parsElixir! --no-pry" && 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
-reg query HKCU\Console /v VirtualTerminalLevel 2>nul | findstr /e "0x1" >nul 2>nul
-if %errorlevel% == 0 (
-  set beforeExtra=-elixir ansi_enabled true !beforeExtra!
+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 ELIXIR_CLI_DRY_RUN (
-   if defined useWerl (
-     echo start "" "!ERTS_BIN!werl.exe" !ext_libs! !ELIXIR_ERL_OPTIONS! !parsErlang! !beforeExtra! -extra !parsElixir!
-   ) else (
-     echo "!ERTS_BIN!erl.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 (
-  if defined useWerl (
-    start "" "!ERTS_BIN!werl.exe" !ext_libs! !ELIXIR_ERL_OPTIONS! !parsErlang! !beforeExtra! -extra !parsElixir!
-  ) else (
-    "!ERTS_BIN!erl.exe" !ext_libs! !ELIXIR_ERL_OPTIONS! !parsErlang! !beforeExtra! -extra !parsElixir!
-  )
+  erl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 )
-exit /B %ERRORLEVEL%
 :end
 endlocal

bin/elixirc

@@ -1,25 +1,20 @@
 #!/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 (standalone)
 
+  --help, -h                Prints this message and exits
   --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
-  --profile time            Profile the time to compile modules
   --verbose                 Prints compilation status
-  --warnings-as-errors      Treats warnings as errors and return non-zero exit status
+  --version, -v             Prints Elixir version and exits
+  --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
 
@@ -29,7 +24,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,16 +14,15 @@ goto run
 :documentation
 echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
 echo.
-echo   -h, --help                Prints this message and exits
 echo   -o                        The directory to output compiled files
-echo   -v, --version             Prints Elixir version and exits (standalone)
 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   --profile time            Profile the time to compile modules
 echo   --verbose                 Prints compilation status
-echo   --warnings-as-errors      Treats warnings as errors and returns non-zero exit status
+echo   --version, -v             Prints Elixir version and exits
+echo   --warnings-as-errors      Treats warnings as errors and returns non-zero exit code
 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,20 +1,35 @@
 #!/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]
+  -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 (*)
+  --help, -h                  Prints this message and exits
+  --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
+  --version, -v               Prints IEx version and exits
+  --werl                      Uses Erlang's Windows shell GUI (Windows only)
 
-  --dot-iex "FILE"    Evaluates FILE, line by line, to set up IEx' environment.
-                      Defaults to evaluating .iex.exs or ~/.iex.exs, if any exists.
-                      If FILE is empty, then no file will be loaded.
-  --remsh NAME        Connects to a node using a remote shell.
-  --no-pry            Doesn't start pry sessions when dbg/2 is called.
+  --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
 
@@ -24,7 +39,7 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 

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,21 +9,38 @@ goto run
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo The following options are exclusive to IEx:
+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 "FILE"    Evaluates FILE, line by line, to set up IEx' environment.
-echo                       Defaults to evaluating .iex.exs or ~/.iex.exs, if any exists.
-echo                       If FILE is 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   --no-pry            Doesn't start pry sessions when dbg/2 is called.
+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   --help, -h                  Prints this message and exits
+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   --version, -v               Prints IEx version and exits
+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=)
+@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% %*
 :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,81 +1,48 @@
 defmodule EEx.SyntaxError do
-  defexception [:message, :file, :line, :column]
+  defexception [:message, :file, :line]
 
-  @impl true
   def message(exception) do
-    "#{exception.file}:#{exception.line}:#{exception.column}: #{exception.message}"
+    "#{exception.file}:#{exception.line}: #{exception.message}"
   end
 end
 
 defmodule EEx do
   @moduledoc ~S"""
-  EEx stands for Embedded Elixir.
+  EEx stands for Embedded Elixir. It allows you to embed
+  Elixir code inside a string in a robust way.
 
-  Embedded Elixir 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"
 
-  This module provides three main APIs for you to use:
+  ## API
 
-    1. Evaluate a string (`eval_string/3`) or a file (`eval_file/3`)
+  This module provides 3 main APIs for you to use:
+
+    1. Evaluate a string (`eval_string`) or a file (`eval_file`)
        directly. This is the simplest API to use but also the
-       slowest, since the code is evaluated at runtime and not precompiled.
+       slowest, since the code is evaluated and not compiled before.
 
-    2. Define a function from a string (`function_from_string/5`)
-       or a file (`function_from_file/5`). This allows you to embed
+    2. Define a function from a string (`function_from_string`)
+       or a file (`function_from_file`). This allows you to embed
        the template as a function inside a module which will then
        be compiled. This is the preferred API if you have access
        to the template at compilation time.
 
-    3. Compile a string (`compile_string/2`) or a file (`compile_file/2`)
+    3. Compile a string (`compile_string`) or a file (`compile_file`)
        into Elixir syntax tree. This is the API used by both functions
        above and is available to you if you want to provide your own
        ways of handling the compiled template.
 
-  The APIs above support several options, documented below. You may
-  also pass an engine which customizes how the EEx code is compiled.
-
   ## Options
 
-  All functions in this module, unless otherwise noted, accept EEx-related
-  options. They are:
+  All functions in this module accept EEx-related options.
+  They are:
 
+    * `:line` - the line to be used as the template start. Defaults to 1.
     * `: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.
-
-    * `:line` - the line to be used as the template start. Defaults to `1`.
-
-    * `:indentation` - (since v1.11.0) an integer added to the column after every
-      new line. Defaults to `0`.
-
+      file the template is read from or to "nofile" when compiling from a string.
     * `:engine` - the EEx engine to be used for compilation.
-
-    * `:trim` - if `true`, trims whitespace left and right of quotation as
-      long as at least one newline is present. All subsequent newlines and
-      spaces are removed but one newline is retained. Defaults to `false`.
-
-    * `:parser_options` - (since: 1.13.0) allow customizing the parsed code
-      that is generated. See `Code.string_to_quoted/2` for available options.
-      Note that the options `:file`, `:line` and `:column` are ignored if
-      passed in. Defaults to `Code.get_compiler_option(:parser_options)`
-      (which defaults to `[]` if not set).
-
-  ## Tags
-
-  EEx supports multiple tags, declared below:
-
-      <% Elixir expression: executes code but discards output %>
-      <%= Elixir expression: executes code and prints result %>
-      <%% EEx quotation: returns the contents inside the tag as is %>
-      <%!-- Comments: they are discarded from source --%>
-
-  EEx supports additional tags, that may be used by some engines,
-  but they do not have a meaning by default:
-
-      <%| ... %>
-      <%/ ... %>
+    * `:trim` - trims whitespace left/right of quotation tags
 
   ## Engine
 
@@ -85,12 +52,38 @@ defmodule EEx do
   By default, `EEx` uses the `EEx.SmartEngine` that provides some
   conveniences on top of the simple `EEx.Engine`.
 
-  ### `EEx.SmartEngine`
+  ### Tags
 
-  The smart engine uses EEx default rules and adds the `@` construct
-  for reading template assigns:
+  `EEx.SmartEngine` supports the following tags:
 
-      iex> EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
+      <% Elixir expression - inline with output %>
+      <%= Elixir expression - replace with result %>
+      <%% EEx quotation - returns the contents inside %>
+      <%# Comments - they are discarded from source %>
+
+  All expressions that output something to the template
+  **must** use the equals sign (`=`). Since everything in
+  Elixir is an expression, there are no exceptions for this rule.
+  For example, while some template languages would special-case
+  `if/2` clauses, they are treated the same in EEx and
+  also require `=` in order to have their result printed:
+
+      <%= if true do %>
+        It is obviously true
+      <% else %>
+        This will never appear
+      <% end %>
+
+  Notice that different engines may have different rules
+  for each tag. Other tags may be added in future versions.
+
+  ### Macros
+
+  `EEx.SmartEngine` also adds some macros to your template.
+  An example is the `@` macro which allows easy data access
+  in a template:
+
+      iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
       "1"
 
   In other words, `<%= @foo %>` translates to:
@@ -101,46 +94,31 @@ defmodule EEx do
   required by the template is not specified at compilation time.
   """
 
-  @type line :: non_neg_integer
-  @type column :: non_neg_integer
-  @type marker :: '=' | '/' | '|' | ''
-  @type metadata :: %{column: column, line: line}
-  @type token ::
-          {:comment, charlist, metadata}
-          | {:text, charlist, metadata}
-          | {:expr | :start_expr | :middle_expr | :end_expr, marker, charlist, metadata}
-          | {:eof, metadata}
-
   @doc """
-  Generates a function definition from the given string.
+  Generates a function definition from the string.
 
-  The first argument is the kind of the generated function (`:def` or `:defp`).
-  The `name` argument is the name that the generated function will have.
-  `template` is the string containing the EEx template. `args` is a list of arguments
-  that the generated function will accept. They will be available inside the EEx
-  template.
-
-  The supported `options` are described [in the module docs](#module-options).
+  The kind (`:def` or `:defp`) must be given, the
+  function name, its arguments and the compilation options.
 
   ## Examples
 
       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"
 
   """
-  defmacro function_from_string(kind, name, template, args \\ [], options \\ []) 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)
-      compiled = EEx.compile_string(template, info)
+      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,17 +126,12 @@ defmodule EEx do
   @doc """
   Generates a function definition from the file contents.
 
-  The first argument is the kind of the generated function (`:def` or `:defp`).
-  The `name` argument is the name that the generated function will have.
-  `file` is the path to the EEx template file. `args` is a list of arguments
-  that the generated function will accept. They will be available inside the EEx
-  template.
+  The kind (`:def` or `:defp`) must be given, the
+  function name, its arguments and the compilation options.
 
   This function is useful in case you have templates but
   you want to precompile inside a module for speed.
 
-  The supported `options` are described [in the module docs](#module-options).
-
   ## Examples
 
       # sample.eex
@@ -167,110 +140,57 @@ 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([file: IO.chardata_to_string(file), line: 1], options)
-      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
 
   @doc """
-  Gets a string `source` and generates a quoted expression
+  Gets a string `source` and generate a quoted expression
   that can be evaluated by Elixir or compiled to a function.
-
-  This is useful if you want to compile a EEx template into code and inject
-  that code somewhere or evaluate it at runtime.
-
-  The generated quoted code will use variables defined in the template that
-  will be taken from the context where the code is evaluated. If you
-  have a template such as `<%= a + b %>`, then the returned quoted code
-  will use the `a` and `b` variables in the context where it's evaluated. See
-  examples below.
-
-  The supported `options` are described [in the module docs](#module-options).
-
-  ## Examples
-
-      iex> quoted = EEx.compile_string("<%= a + b %>")
-      iex> {result, _bindings} = Code.eval_quoted(quoted, a: 1, b: 2)
-      iex> result
-      "3"
-
   """
-  @spec compile_string(String.t(), keyword) :: Macro.t()
+  @spec compile_string(String.t, keyword) :: Macro.t | no_return
   def compile_string(source, options \\ []) when is_binary(source) and is_list(options) do
-    case tokenize(source, options) do
-      {:ok, tokens} ->
-        EEx.Compiler.compile(tokens, options)
-
-      {:error, message, %{column: column, line: line}} ->
-        file = options[:file] || "nofile"
-        raise EEx.SyntaxError, file: file, line: line, column: column, message: message
-    end
+    EEx.Compiler.compile(source, options)
   end
 
   @doc """
-  Gets a `filename` and generates a quoted expression
+  Gets a `filename` and generate a quoted expression
   that can be evaluated by Elixir or compiled to a function.
-
-  This is useful if you want to compile a EEx template into code and inject
-  that code somewhere or evaluate it at runtime.
-
-  The generated quoted code will use variables defined in the template that
-  will be taken from the context where the code is evaluated. If you
-  have a template such as `<%= a + b %>`, then the returned quoted code
-  will use the `a` and `b` variables in the context where it's evaluated. See
-  examples below.
-
-  The supported `options` are described [in the module docs](#module-options).
-
-  ## Examples
-
-      # sample.eex
-      <%= a + b %>
-
-      # In code:
-      quoted = EEx.compile_file("sample.eex")
-      {result, _bindings} = Code.eval_quoted(quoted, a: 1, b: 2)
-      result
-      #=> "3"
-
   """
-  @spec compile_file(Path.t(), keyword) :: Macro.t()
-  def compile_file(filename, options \\ []) when is_list(options) do
-    filename = IO.chardata_to_string(filename)
-    options = Keyword.merge([file: filename, line: 1], options)
+  @spec compile_file(String.t, keyword) :: 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]
     compile_string(File.read!(filename), options)
   end
 
   @doc """
   Gets a string `source` and evaluate the values using the `bindings`.
 
-  The supported `options` are described [in the module docs](#module-options).
-
   ## 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) :: String.t()
+  @spec eval_string(String.t, keyword, keyword) :: 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)
@@ -280,64 +200,23 @@ defmodule EEx do
   @doc """
   Gets a `filename` and evaluate the values using the `bindings`.
 
-  The supported `options` are described [in the module docs](#module-options).
-
   ## Examples
 
       # sample.eex
       foo <%= bar %>
 
-      # IEx
-      EEx.eval_file("sample.eex", bar: "baz")
-      #=> "foo baz"
+      # iex
+      EEx.eval_file "sample.eex", [bar: "baz"] #=> "foo baz"
 
   """
-  @spec eval_file(Path.t(), keyword, keyword) :: String.t()
+  @spec eval_file(String.t, keyword, keyword) :: any
   def eval_file(filename, bindings \\ [], options \\ [])
-      when is_list(bindings) and is_list(options) do
-    filename = IO.chardata_to_string(filename)
-    options = Keyword.put_new(options, :file, filename)
+      when is_binary(filename) and is_list(bindings) and is_list(options) do
+    options  = Keyword.put options, :file, filename
     compiled = compile_file(filename, options)
     do_eval(compiled, bindings, options)
   end
 
-  @doc """
-  Tokenize the given contents according to the given options.
-
-  ## Options
-
-    * `:line` - An integer to start as line. Default is 1.
-    * `:column` - An integer to start as column. Default is 1.
-    * `:indentation` - An integer that indicates the indentation. Default is 0.
-    * `:trim` - Tells the tokenizer to either trim the content or not. Default is false.
-    * `:file` - Can be either a file or a string "nofile".
-
-  ## Examples
-
-      iex> EEx.tokenize('foo', line: 1, column: 1)
-      {:ok, [{:text, 'foo', %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
-
-  ## Result
-
-  It returns `{:ok, [token]}` where a token is one of:
-
-    * `{:text, content, %{column: column, line: line}}`
-    * `{:expr, marker, content, %{column: column, line: line}}`
-    * `{:start_expr, marker, content, %{column: column, line: line}}`
-    * `{:middle_expr, marker, content, %{column: column, line: line}}`
-    * `{:end_expr, marker, content, %{column: column, line: line}}`
-    * `{:eof, %{column: column, line: line}}`
-
-  Or `{:error, message, %{column: column, line: line}}` in case of errors.
-  Note new tokens may be added in the future.
-  """
-  @doc since: "1.14.0"
-  @spec tokenize(IO.chardata(), opts :: keyword) ::
-          {:ok, [token()]} | {:error, String.t(), metadata()}
-  def tokenize(contents, opts \\ []) do
-    EEx.Compiler.tokenize(contents, opts)
-  end
-
   ### Helpers
 
   defp do_eval(compiled, bindings, options) do

lib/eex/lib/eex/compiler.ex

@@ -3,415 +3,93 @@ defmodule EEx.Compiler do
 
   # When changing this setting, don't forget to update the docs for EEx
   @default_engine EEx.SmartEngine
-  @h_spaces [?\s, ?\t]
-  @all_spaces [?\s, ?\t, ?\n, ?\r]
-
-  @doc """
-  Tokenize EEx contents.
-  """
-  def tokenize(contents, opts) when is_binary(contents) do
-    tokenize(String.to_charlist(contents), opts)
-  end
-
-  def tokenize(contents, opts) when is_list(contents) do
-    file = opts[:file] || "nofile"
-    line = opts[:line] || 1
-    trim = opts[:trim] || false
-    indentation = opts[:indentation] || 0
-    column = indentation + (opts[:column] || 1)
-
-    state = %{trim: trim, indentation: indentation, file: file}
-
-    {contents, line, column} =
-      (trim && trim_init(contents, line, column, state)) || {contents, line, column}
-
-    tokenize(contents, line, column, state, [{line, column}], [])
-  end
-
-  defp tokenize('<%%' ++ t, line, column, state, buffer, acc) do
-    tokenize(t, line, column + 3, state, [?%, ?< | buffer], acc)
-  end
-
-  defp tokenize('<%!--' ++ t, line, column, state, buffer, acc) do
-    case comment(t, line, column + 5, state, []) do
-      {:error, line, column, message} ->
-        {:error, message, %{line: line, column: column}}
-
-      {:ok, new_line, new_column, rest, comments} ->
-        token = {:comment, Enum.reverse(comments), %{line: line, column: column}}
-        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])
-    end
-  end
-
-  # TODO: Deprecate this on Elixir v1.18
-  defp tokenize('<%#' ++ t, line, column, state, buffer, acc) do
-    case expr(t, line, column + 3, state, []) do
-      {:error, line, column, message} ->
-        {:error, message, %{line: line, column: column}}
-
-      {:ok, _, new_line, new_column, rest} ->
-        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, & &1)
-    end
-  end
-
-  defp tokenize('<%' ++ t, line, column, state, buffer, acc) do
-    {marker, t} = retrieve_marker(t)
-
-    case expr(t, line, column + 2 + length(marker), state, []) do
-      {:error, line, column, message} ->
-        {:error, message, %{line: line, column: column}}
-
-      {:ok, expr, new_line, new_column, rest} ->
-        {key, expr} =
-          case :elixir_tokenizer.tokenize(expr, 1, file: "eex", check_terminators: false) do
-            {:ok, _line, _column, warnings, tokens} ->
-              Enum.each(Enum.reverse(warnings), fn {location, file, msg} ->
-                :elixir_errors.erl_warn(location, file, msg)
-              end)
-
-              token_key(tokens, expr)
-
-            {:error, _, _, _, _} ->
-              {:expr, expr}
-          end
-
-        marker =
-          if key in [:middle_expr, :end_expr] and marker != '' do
-            message =
-              "unexpected beginning of EEx tag \"<%#{marker}\" on \"<%#{marker}#{expr}%>\", " <>
-                "please remove \"#{marker}\""
-
-            :elixir_errors.erl_warn({line, column}, state.file, message)
-            ''
-          else
-            marker
-          end
-
-        token = {key, marker, expr, %{line: line, column: column}}
-        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])
-    end
-  end
-
-  defp tokenize('\n' ++ t, line, _column, state, buffer, acc) do
-    tokenize(t, line + 1, state.indentation + 1, state, [?\n | buffer], acc)
-  end
-
-  defp tokenize([h | t], line, column, state, buffer, acc) do
-    tokenize(t, line, column + 1, state, [h | buffer], acc)
-  end
-
-  defp tokenize([], line, column, _state, buffer, acc) do
-    eof = {:eof, %{line: line, column: column}}
-    {:ok, Enum.reverse([eof | tokenize_text(buffer, acc)])}
-  end
-
-  defp trim_and_tokenize(rest, line, column, state, buffer, acc, fun) do
-    {rest, line, column, buffer} = trim_if_needed(rest, line, column, state, buffer)
-
-    acc = tokenize_text(buffer, acc)
-    tokenize(rest, line, column, state, [{line, column}], fun.(acc))
-  end
-
-  # Retrieve marker for <%
-
-  defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do
-    {[marker], t}
-  end
-
-  defp retrieve_marker(t) do
-    {'', t}
-  end
-
-  # Tokenize a multi-line comment until we find --%>
-
-  defp comment([?-, ?-, ?%, ?> | t], line, column, _state, buffer) do
-    {:ok, line, column + 4, t, buffer}
-  end
-
-  defp comment('\n' ++ t, line, _column, state, buffer) do
-    comment(t, line + 1, state.indentation + 1, state, '\n' ++ buffer)
-  end
-
-  defp comment([head | t], line, column, state, buffer) do
-    comment(t, line, column + 1, state, [head | buffer])
-  end
-
-  defp comment([], line, column, _state, _buffer) do
-    {:error, line, column, "missing token '--%>'"}
-  end
-
-  # Tokenize an expression until we find %>
-
-  defp expr([?%, ?> | t], line, column, _state, buffer) do
-    {:ok, Enum.reverse(buffer), line, column + 2, t}
-  end
-
-  defp expr('\n' ++ t, line, _column, state, buffer) do
-    expr(t, line + 1, state.indentation + 1, state, [?\n | buffer])
-  end
-
-  defp expr([h | t], line, column, state, buffer) do
-    expr(t, line, column + 1, state, [h | buffer])
-  end
-
-  defp expr([], line, column, _state, _buffer) do
-    {:error, line, column, "missing token '%>'"}
-  end
-
-  # Receives tokens and check if it is a start, middle or an end token.
-  defp token_key(tokens, expr) do
-    case {tokens, tokens |> Enum.reverse() |> drop_eol()} do
-      {[{:end, _} | _], [{:do, _} | _]} ->
-        {:middle_expr, expr}
-
-      {_, [{:do, _} | _]} ->
-        {:start_expr, maybe_append_space(expr)}
-
-      {_, [{:block_identifier, _, _} | _]} ->
-        {:middle_expr, maybe_append_space(expr)}
-
-      {[{:end, _} | _], [{:stab_op, _, _} | _]} ->
-        {:middle_expr, expr}
-
-      {_, [{:stab_op, _, _} | reverse_tokens]} ->
-        fn_index = Enum.find_index(reverse_tokens, &match?({:fn, _}, &1)) || :infinity
-        end_index = Enum.find_index(reverse_tokens, &match?({:end, _}, &1)) || :infinity
-
-        if end_index > fn_index do
-          {:start_expr, expr}
-        else
-          {:middle_expr, expr}
-        end
-
-      {tokens, _} ->
-        case Enum.drop_while(tokens, &closing_bracket?/1) do
-          [{:end, _} | _] -> {:end_expr, expr}
-          _ -> {:expr, expr}
-        end
-    end
-  end
-
-  defp drop_eol([{:eol, _} | rest]), do: drop_eol(rest)
-  defp drop_eol(rest), do: rest
-
-  defp maybe_append_space([?\s]), do: [?\s]
-  defp maybe_append_space([h]), do: [h, ?\s]
-  defp maybe_append_space([h | t]), do: [h | maybe_append_space(t)]
-
-  defp closing_bracket?({closing, _}) when closing in ~w"( [ {"a, do: true
-  defp closing_bracket?(_), do: false
-
-  # Tokenize the buffered text by appending
-  # it to the given accumulator.
-
-  defp tokenize_text([{_line, _column}], acc) do
-    acc
-  end
-
-  defp tokenize_text(buffer, acc) do
-    [{line, column} | buffer] = Enum.reverse(buffer)
-    [{:text, buffer, %{line: line, column: column}} | acc]
-  end
-
-  ## Trim
-
-  defp trim_if_needed(rest, line, column, state, buffer) do
-    if state.trim do
-      buffer = trim_left(buffer, 0)
-      {rest, line, column} = trim_right(rest, line, column, 0, state)
-      {rest, line, column, buffer}
-    else
-      {rest, line, column, buffer}
-    end
-  end
-
-  defp trim_init([h | t], line, column, state) when h in @h_spaces,
-    do: trim_init(t, line, column + 1, state)
-
-  defp trim_init([?\r, ?\n | t], line, _column, state),
-    do: trim_init(t, line + 1, state.indentation + 1, state)
-
-  defp trim_init([?\n | t], line, _column, state),
-    do: trim_init(t, line + 1, state.indentation + 1, state)
-
-  defp trim_init([?<, ?% | _] = rest, line, column, _state),
-    do: {rest, line, column}
-
-  defp trim_init(_, _, _, _), do: false
-
-  defp trim_left(buffer, count) do
-    case trim_whitespace(buffer, 0) do
-      {[?\n, ?\r | rest], _} -> trim_left(rest, count + 1)
-      {[?\n | rest], _} -> trim_left(rest, count + 1)
-      _ when count > 0 -> [?\n | buffer]
-      _ -> buffer
-    end
-  end
-
-  defp trim_right(rest, line, column, last_column, state) do
-    case trim_whitespace(rest, column) do
-      {[?\r, ?\n | rest], column} ->
-        trim_right(rest, line + 1, state.indentation + 1, column + 1, state)
-
-      {[?\n | rest], column} ->
-        trim_right(rest, line + 1, state.indentation + 1, column, state)
-
-      {[], column} ->
-        {[], line, column}
-
-      _ when last_column > 0 ->
-        {[?\n | rest], line - 1, last_column}
-
-      _ ->
-        {rest, line, column}
-    end
-  end
-
-  defp trim_whitespace([h | t], column) when h in @h_spaces, do: trim_whitespace(t, column + 1)
-  defp trim_whitespace(list, column), do: {list, column}
 
   @doc """
   This is the compilation entry point. It glues the tokenizer
   and the engine together by handling the tokens and invoking
   the engine every time a full expression or text is received.
   """
-  @spec compile([EEx.token()], keyword) :: Macro.t()
-  def compile(tokens, opts) do
+  @spec compile(String.t, keyword) :: 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
-    parser_options = opts[:parser_options] || Code.get_compiler_option(:parser_options)
-    engine = opts[:engine] || @default_engine
-
-    state = %{
-      engine: engine,
-      file: file,
-      line: line,
-      quoted: [],
-      start_line: nil,
-      start_column: nil,
-      parser_options: parser_options
-    }
-
-    init = state.engine.init(opts)
-    generate_buffer(tokens, init, [], state)
-  end
-
-  # Ignore tokens related to comment.
-  defp generate_buffer([{:comment, _chars, _meta} | rest], buffer, scope, state) do
-    generate_buffer(rest, buffer, scope, state)
+    trim = opts[:trim] || false
+    case EEx.Tokenizer.tokenize(source, line, trim: trim) do
+      {:ok, tokens} ->
+        state = %{engine: opts[:engine] || @default_engine, init: nil,
+                  file: file, line: line, quoted: [], start_line: nil}
+        init = state.engine.init(opts)
+        generate_buffer(tokens, init, [], %{state | init: init})
+      {:error, line, message} ->
+        raise EEx.SyntaxError, line: line, file: file, message: message
+    end
   end
 
   # Generates the buffers by handling each expression from the tokenizer.
   # It returns Macro.t/0 or it raises.
 
-  defp generate_buffer([{:text, chars, meta} | rest], buffer, scope, state) do
-    buffer =
-      if function_exported?(state.engine, :handle_text, 3) do
-        meta = [line: meta.line, column: meta.column]
-        state.engine.handle_text(buffer, meta, IO.chardata_to_string(chars))
-      else
-        # TODO: Deprecate this branch on Elixir v1.18.
-        # We should most likely move this check to init to emit the deprecation once.
-        state.engine.handle_text(buffer, IO.chardata_to_string(chars))
-      end
-
+  defp generate_buffer([{:text, chars} | rest], buffer, scope, state) do
+    buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
     generate_buffer(rest, buffer, scope, state)
   end
 
-  defp generate_buffer([{:expr, mark, chars, meta} | rest], buffer, scope, state) do
-    options =
-      [file: state.file, line: meta.line, column: column(meta.column, mark)] ++
-        state.parser_options
-
-    expr = Code.string_to_quoted!(chars, options)
+  defp generate_buffer([{:expr, line, mark, chars} | rest], 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)
   end
 
-  defp generate_buffer(
-         [{:start_expr, mark, chars, meta} | rest],
-         buffer,
-         scope,
-         state
-       ) do
-    if mark == '' do
-      message =
-        "the contents of this expression won't be output unless the EEx block starts with \"<%=\""
-
-      :elixir_errors.erl_warn({meta.line, meta.column}, state.file, message)
-    end
-
-    {rest, line, contents} = look_ahead_middle(rest, meta.line, chars) || {rest, meta.line, chars}
-
+  defp generate_buffer([{:start_expr, start_line, mark, chars} | rest], buffer, scope, state) do
+    {contents, line, rest} = look_ahead_text(rest, start_line, chars)
     {contents, rest} =
-      generate_buffer(
-        rest,
-        state.engine.handle_begin(buffer),
-        [contents | scope],
-        %{
-          state
-          | quoted: [],
-            line: line,
-            start_line: meta.line,
-            start_column: column(meta.column, mark)
-        }
-      )
-
+      generate_buffer(rest, state.init, [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)
   end
 
-  defp generate_buffer(
-         [{:middle_expr, '', chars, meta} | rest],
-         buffer,
-         [current | scope],
-         state
-       ) do
-    {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)
-    state = %{state | line: meta.line}
-    generate_buffer(rest, state.engine.handle_begin(buffer), [wrapped | scope], state)
+  defp generate_buffer([{:middle_expr, line, '', chars} | rest], buffer, [current | scope], state) do
+    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
+    generate_buffer(rest, state.init, [wrapped | scope], %{state | line: line})
   end
 
-  defp generate_buffer([{:middle_expr, _, chars, meta} | _], _buffer, [], state) do
-    raise EEx.SyntaxError,
-      message: "unexpected middle of expression <%#{chars}%>",
-      file: state.file,
-      line: meta.line,
-      column: meta.column
+  defp generate_buffer([{:middle_expr, line, modifier, chars} | t], buffer, scope, state) do
+    message = "unexpected beginning of EEx tag \"<%#{modifier}\" on \"<%#{modifier}#{chars}%>\", " <>
+              "please remove \"#{modifier}\" accordingly"
+    :elixir_errors.warn line, state.file, message
+    generate_buffer([{:middle_expr, line, '', chars} | 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, '', chars, meta} | rest],
-         buffer,
-         [current | _],
-         state
-       ) do
-    {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)
-    column = state.start_column
-    options = [file: state.file, line: state.start_line, column: column] ++ state.parser_options
-    tuples = Code.string_to_quoted!(wrapped, options)
+  defp generate_buffer([{:end_expr, line, '', chars} | rest], 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])
     buffer = insert_quoted(tuples, state.quoted)
     {buffer, rest}
   end
 
-  defp generate_buffer([{:end_expr, _, chars, meta} | _], _buffer, [], state) do
-    raise EEx.SyntaxError,
-      message: "unexpected end of expression <%#{chars}%>",
-      file: state.file,
-      line: meta.line,
-      column: meta.column
+  defp generate_buffer([{:end_expr, line, modifier, chars} | t], buffer, [_ | _] = scope, state) do
+    message = "unexpected beginning of EEx tag \"<%#{modifier}\" on end of expression \"<%#{modifier}#{chars}%>\", " <>
+              "please remove \"#{modifier}\" accordingly"
+    :elixir_errors.warn line, state.file, message
+    generate_buffer([{:end_expr, line, '', chars} | 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([{:eof, _meta}], buffer, [], state) do
+  defp generate_buffer([{:end_expr, line, _, chars} | _], _buffer, [], state) do
+    raise EEx.SyntaxError, message: "unexpected end of expression <%#{chars}%>",
+                           file: state.file, line: line
+  end
+
+  defp generate_buffer([], buffer, [], state) do
     state.engine.handle_body(buffer)
   end
 
-  defp generate_buffer([{:eof, meta}], _buffer, _scope, state) do
-    raise EEx.SyntaxError,
-      message: "unexpected end of string, expected a closing '<% end %>'",
-      file: state.file,
-      line: meta.line,
-      column: meta.column
+  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
   end
 
   # Creates a placeholder and wrap it inside the expression block
@@ -420,41 +98,34 @@ 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([{:comment, _comment, _meta} | rest], start, contents),
-    do: look_ahead_middle(rest, start, contents)
-
-  defp look_ahead_middle([{:text, text, _meta} | rest], start, contents) do
+  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars} | rest] = tokens, start, contents) do
     if only_spaces?(text) do
-      look_ahead_middle(rest, start, contents ++ text)
+      {contents ++ text ++ chars, line, rest}
     else
-      nil
+      {contents, start, tokens}
     end
   end
-
-  defp look_ahead_middle([{:middle_expr, _, chars, meta} | rest], _start, contents) do
-    {rest, meta.line, contents ++ chars}
+  defp look_ahead_text([{:middle_expr, line, _, chars} | rest], _start, contents) do
+    {contents ++ chars, line, rest}
   end
-
-  defp look_ahead_middle(_tokens, _start, _contents) do
-    nil
+  defp look_ahead_text(tokens, start, contents) do
+    {contents, start, tokens}
   end
 
   defp only_spaces?(chars) do
-    Enum.all?(chars, &(&1 in @all_spaces))
+    Enum.all?(chars, &(&1 in [?\s, ?\t, ?\r, ?\n]))
   end
 
   # 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
 
@@ -467,15 +138,10 @@ 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
     other
   end
-
-  defp column(column, mark) do
-    # length('<%') == 2
-    column + 2 + length(mark)
-  end
 end

lib/eex/lib/eex/engine.ex

@@ -2,73 +2,37 @@ 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:
 
-  This module also ships with a default engine implementation
-  you can delegate to. See `EEx.SmartEngine` as an example.
+    * `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, [line: pos_integer, column: pos_integer], 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) :: 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
-  @deprecated "Use explicit delegation to EEx.Engine instead"
   defmacro __using__(_) do
     quote do
       @behaviour EEx.Engine
@@ -77,24 +41,16 @@ 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)
-      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)
+      def handle_expr(buffer, marker, expr) do
+        EEx.Engine.handle_expr(buffer, marker, expr)
       end
 
       defoverridable EEx.Engine
@@ -110,112 +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!(Access.t, Access.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 "Default implementation for `c:init/1`."
+  @doc """
+  Returns an empty string as initial buffer.
+  """
   def init(_opts) do
-    %{
-      binary: [],
-      dynamic: [],
-      vars_count: 0
-    }
+    ""
   end
 
-  @doc "Default implementation for `c:handle_begin/1`."
-  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 "Default implementation for `c:handle_end/1`."
-  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 "Default implementation for `c:handle_body/1`."
-  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 "Default implementation for `c:handle_text/3`."
-  def handle_text(state, _meta, text) do
-    check_state!(state)
-    %{binary: binary} = state
-    %{state | binary: [text | binary]}
-  end
-
-  @doc "Default implementation for `c:handle_expr/3`."
-  def handle_expr(state, "=", ast) do
-    check_state!(state)
-    %{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,35 +24,18 @@ 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"
 
   """
 
-  @behaviour EEx.Engine
+  use EEx.Engine
 
-  @impl true
-  defdelegate init(opts), to: EEx.Engine
-
-  @impl true
-  defdelegate handle_body(state), to: EEx.Engine
-
-  @impl true
-  defdelegate handle_begin(state), to: EEx.Engine
-
-  @impl true
-  defdelegate handle_end(state), to: EEx.Engine
-
-  @impl true
-  defdelegate handle_text(state, meta, text), to: EEx.Engine
-
-  @impl true
-  def handle_expr(state, marker, expr) do
+  def handle_expr(buffer, mark, expr) do
     expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
-    EEx.Engine.handle_expr(state, marker, expr)
+    super(buffer, mark, expr)
   end
 end

lib/eex/lib/eex/tokenizer.ex

@@ -0,0 +1,222 @@
+defmodule EEx.Tokenizer do
+  @moduledoc false
+
+  @type content :: IO.chardata
+  @type line :: non_neg_integer
+  @type token :: {:text, content} |
+                 {:expr | :start_expr | :middle_expr | :end_expr, line, '=' | '', content}
+
+  @doc """
+  Tokenizes the given charlist or binary.
+
+  It returns {:ok, list} with the following tokens:
+
+    * `{:text, content}`
+    * `{: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}
+  def tokenize(bin, line, opts \\ [])
+
+  def tokenize(bin, line, opts)
+      when is_binary(bin) and is_integer(line) and line >= 0 and is_list(opts) do
+    tokenize(String.to_charlist(bin), line, opts)
+  end
+
+  def tokenize(list, line, opts)
+      when is_list(list) and is_integer(line) and line >= 0 and is_list(opts) do
+    tokenize(list, line, opts, [], [])
+  end
+
+  defp tokenize('<%%' ++ t, line, opts, buffer, acc) do
+   tokenize t, line, opts, [?%, ?< | buffer], acc
+  end
+
+  defp tokenize('<%#' ++ t, line, opts, buffer, acc) do
+    case expr(t, line, []) do
+      {: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
+    end
+  end
+
+  defp tokenize('<%' ++ t, line, opts, buffer, acc) do
+    {marker, t} = retrieve_marker(t)
+
+    case expr(t, line, []) do
+      {:error, _, _} = error -> error
+      {:ok, expr, new_line, rest} ->
+        token = token_name(expr)
+        {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
+  end
+
+  defp tokenize([h | t], line, opts, buffer, acc) do
+    tokenize t, line, opts, [h | buffer], acc
+  end
+
+  defp tokenize([], _line, _opts, buffer, acc) do
+    {:ok, Enum.reverse(tokenize_text(buffer, acc))}
+  end
+
+  # Retrieve marker for <%
+
+  defp retrieve_marker('=' ++ t) do
+    {'=', t}
+  end
+
+  defp retrieve_marker(t) do
+    {'', t}
+  end
+
+  # Tokenize an expression until we find %>
+
+  defp expr([?%, ?> | t], line, buffer) do
+    {:ok, buffer, line, t}
+  end
+
+  defp expr('\n' ++ t, line, buffer) do
+    expr t, line + 1, [?\n | buffer]
+  end
+
+  defp expr([h | t], line, buffer) do
+    expr t, line, [h | buffer]
+  end
+
+  defp expr([], line, _buffer) do
+    {:error, line, "missing token '%>'"}
+  end
+
+  # Receive an expression content and check
+  # if it is a start, middle or an end token.
+  #
+  # Start tokens finish with "do" and "fn ->"
+  # Middle tokens are marked with "->" or keywords
+  # End tokens contain only the end word and optionally ")"
+
+  defp token_name([h | t]) when h in [?\s, ?\t, ?)] do
+    token_name(t)
+  end
+
+  defp token_name('od' ++ [h | _]) when h in [?\s, ?\t, ?)] do
+    :start_expr
+  end
+
+  defp token_name('>-' ++ rest) do
+    rest = Enum.reverse(rest)
+
+    # 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
+          :start_expr
+        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('eucser' ++ t), do: check_spaces(t, :middle_expr)
+  defp token_name('dne' ++ t),    do: check_spaces(t, :end_expr)
+
+  defp token_name(_) do
+    :expr
+  end
+
+  defp fn_index(tokens) do
+    Enum.find_index tokens, fn
+      {:fn_paren, _} -> true
+      {:fn, _}       -> true
+      _              -> false
+    end
+  end
+
+  defp end_index(tokens) do
+    Enum.find_index(tokens, &match?({:end, _}, &1)) || :infinity
+  end
+
+  defp check_spaces(string, token) do
+    if Enum.all?(string, &(&1 in [?\s, ?\t])) do
+      token
+    else
+      :expr
+    end
+  end
+
+  # Tokenize the buffered text by appending
+  # it to the given accumulator.
+
+  defp tokenize_text([], acc) do
+    acc
+  end
+
+  defp tokenize_text(buffer, acc) do
+    [{:text, Enum.reverse(buffer)} | acc]
+  end
+
+  # If trim mode is enabled and the token is on a line with
+  # 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
+    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
+      original
+    end
+  end
+
+  defp trim_left(buffer, acc) do
+    case {trim_whitespace(buffer), acc} do
+      {[?\n | _] = trimmed_buffer, _} -> {true, trimmed_buffer}
+      {[], []} -> {true, []}
+      _ -> {false, buffer}
+    end
+  end
+
+  defp trim_right(rest, line) do
+    case trim_whitespace(rest) do
+      [?\r, ?\n | trimmed_rest] -> {true, trimmed_rest, line + 1}
+      [?\n | trimmed_rest] -> {true, trimmed_rest, line + 1}
+      [] -> {true, [], line}
+      _ -> {false, rest, line}
+    end
+  end
+
+  defp trim_whitespace([h | t]) when h == ?\s or h == ?\t do
+    trim_whitespace(t)
+  end
+
+  defp trim_whitespace(list) do
+    list
+  end
+end

lib/eex/mix.exs

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

lib/eex/test/eex/smart_engine_test.exs

@@ -1,55 +1,40 @@
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.SmartEngineTest do
-  use ExUnit.Case, async: true
+  # TODO: Make this async: true once capture_io is removed
+  use ExUnit.Case
 
   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 = ExUnit.CaptureIO.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 "preserves 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
-
-  test "error with unused \"do\" block without \"<%=\" modifier" do
-    stderr =
-      ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        assert_eval("", "<% if true do %>I'm invisible!<% end %>", assigns: %{})
-      end)
-
-    assert stderr =~ "the contents of this expression won't be output"
   end
 
   defp assert_eval(expected, actual, binding \\ []) do

lib/eex/test/eex/tokenizer_test.exs

@@ -1,371 +1,154 @@
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.TokenizerTest do
   use ExUnit.Case, async: true
-
-  @opts [indentation: 0, trim: false]
+  require EEx.Tokenizer, as: T
 
   test "simple chars lists" do
-    assert EEx.tokenize('foo', @opts) ==
-             {:ok, [{:text, 'foo', %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
+    assert T.tokenize('foo', 1) == {:ok, [{:text, 'foo'}]}
   end
 
   test "simple strings" do
-    assert EEx.tokenize("foo", @opts) ==
-             {:ok, [{:text, 'foo', %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
+    assert T.tokenize("foo", 1) == {:ok, [{:text, 'foo'}]}
   end
 
   test "strings with embedded code" do
-    assert EEx.tokenize('foo <% bar %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo ', %{column: 1, line: 1}},
-                {:expr, '', ' bar ', %{column: 5, line: 1}},
-                {:eof, %{column: 14, line: 1}}
-              ]}
+    assert T.tokenize('foo <% bar %>', 1) ==
+           {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar '}]}
   end
 
   test "strings with embedded equals code" do
-    assert EEx.tokenize('foo <%= bar %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo ', %{column: 1, line: 1}},
-                {:expr, '=', ' bar ', %{column: 5, line: 1}},
-                {:eof, %{column: 15, line: 1}}
-              ]}
-  end
-
-  test "strings with embedded slash code" do
-    assert EEx.tokenize('foo <%/ bar %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo ', %{column: 1, line: 1}},
-                {:expr, '/', ' bar ', %{column: 5, line: 1}},
-                {:eof, %{column: 15, line: 1}}
-              ]}
-  end
-
-  test "strings with embedded pipe code" do
-    assert EEx.tokenize('foo <%| bar %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo ', %{column: 1, line: 1}},
-                {:expr, '|', ' bar ', %{column: 5, line: 1}},
-                {:eof, %{column: 15, line: 1}}
-              ]}
+    assert T.tokenize('foo <%= bar %>', 1) ==
+           {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar '}]}
   end
 
   test "strings with more than one line" do
-    assert EEx.tokenize('foo\n<%= bar %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo\n', %{column: 1, line: 1}},
-                {:expr, '=', ' bar ', %{column: 1, line: 2}},
-                {:eof, %{column: 11, line: 2}}
-              ]}
+    assert T.tokenize('foo\n<%= bar %>', 1) ==
+           {: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 = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:expr, '=', ' bar\n\nbaz ', %{column: 5, line: 1}},
-      {:text, '\n', %{column: 7, line: 3}},
-      {:expr, '', ' foo ', %{column: 1, line: 4}},
-      {:text, '\n', %{column: 10, line: 4}},
-      {:eof, %{column: 1, line: 5}}
-    ]
-
-    assert EEx.tokenize(string, @opts) == {:ok, exprs}
+    assert T.tokenize(string, 1) == {:ok, [
+      {:text, 'foo '},
+      {:expr, 1, '=', ' bar\n\nbaz '},
+      {:text, '\n'},
+      {:expr, 4, '', ' foo '},
+      {:text, '\n'}
+    ]}
   end
 
   test "quotation" do
-    assert EEx.tokenize('foo <%% true %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo <% true %>', %{column: 1, line: 1}},
-                {:eof, %{column: 16, line: 1}}
-              ]}
+    assert T.tokenize('foo <%% true %>', 1) == {:ok, [
+      {:text, 'foo <% true %>'}
+    ]}
   end
 
-  test "quotation with do-end" do
-    assert EEx.tokenize('foo <%% true do %>bar<%% end %>', @opts) ==
-             {:ok,
-              [
-                {:text, 'foo <% true do %>bar<% end %>', %{column: 1, line: 1}},
-                {:eof, %{column: 32, line: 1}}
-              ]}
+  test "quotation with do/end" do
+    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == {:ok, [
+      {:text, 'foo <% true do %>bar<% end %>'}
+    ]}
   end
 
   test "quotation with interpolation" do
-    exprs = [
-      {:text, 'a <% b ', %{column: 1, line: 1}},
-      {:expr, '=', ' c ', %{column: 9, line: 1}},
-      {:text, ' ', %{column: 17, line: 1}},
-      {:expr, '=', ' d ', %{column: 18, line: 1}},
-      {:text, ' e %> f', %{column: 26, line: 1}},
-      {:eof, %{column: 33, line: 1}}
-    ]
+    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, [
+      {:text, 'a <% b '},
+      {:expr, 1, '=', ' c '},
+      {:text, ' '},
+      {:expr, 1, '=', ' d '},
+      {:text, ' e %> f'}
+    ]}
 
-    assert EEx.tokenize('a <%% b <%= c %> <%= d %> e %> f', @opts) == {:ok, exprs}
+    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, [
+      {:text, '<%% a <%= b %> c %>'}
+    ]}
   end
 
-  test "improperly formatted quotation with interpolation" do
-    exprs = [
-      {:text, '<%% a <%= b %> c %>', %{column: 1, line: 1}},
-      {:eof, %{column: 22, line: 1}}
-    ]
-
-    assert EEx.tokenize('<%%% a <%%= b %> c %>', @opts) == {:ok, exprs}
+  test "comments" do
+    assert T.tokenize('foo <%# true %>', 1) == {:ok, [
+      {:text, 'foo '}
+    ]}
   end
 
-  test "EEx comments" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:eof, %{column: 16, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <%# true %>', @opts) == {:ok, exprs}
-
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:eof, %{column: 8, line: 2}}
-    ]
-
-    assert EEx.tokenize('foo <%#\ntrue %>', @opts) == {:ok, exprs}
-  end
-
-  test "EEx comments with do-end" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:text, 'bar', %{column: 19, line: 1}},
-      {:eof, %{column: 32, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <%# true do %>bar<%# end %>', @opts) == {:ok, exprs}
-  end
-
-  test "EEx comments inside do-end" do
-    exprs = [
-      {:start_expr, '', ' if true do ', %{column: 1, line: 1}},
-      {:text, 'bar', %{column: 31, line: 1}},
-      {:end_expr, [], ' end ', %{column: 34, line: 1}},
-      {:eof, %{column: 43, line: 1}}
-    ]
-
-    assert EEx.tokenize('<% if true do %><%# comment %>bar<% end %>', @opts) == {:ok, exprs}
-
-    exprs = [
-      {:start_expr, [], ' case true do ', %{column: 1, line: 1}},
-      {:middle_expr, '', ' true -> ', %{column: 33, line: 1}},
-      {:text, 'bar', %{column: 46, line: 1}},
-      {:end_expr, [], ' end ', %{column: 49, line: 1}},
-      {:eof, %{column: 58, line: 1}}
-    ]
-
-    assert EEx.tokenize('<% case true do %><%# comment %><% true -> %>bar<% end %>', @opts) ==
-             {:ok, exprs}
-  end
-
-  test "EEx multi-line comments" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:comment, ' true ', %{column: 5, line: 1}},
-      {:text, ' bar', %{column: 20, line: 1}},
-      {:eof, %{column: 24, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <%!-- true --%> bar', @opts) == {:ok, exprs}
-
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:comment, ' \ntrue\n ', %{column: 5, line: 1}},
-      {:text, ' bar', %{column: 6, line: 3}},
-      {:eof, %{column: 10, line: 3}}
-    ]
-
-    assert EEx.tokenize('foo <%!-- \ntrue\n --%> bar', @opts) == {:ok, exprs}
-
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:comment, ' <%= true %> ', %{column: 5, line: 1}},
-      {:text, ' bar', %{column: 27, line: 1}},
-      {:eof, %{column: 31, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <%!-- <%= true %> --%> bar', @opts) == {:ok, exprs}
-  end
-
-  test "Elixir comments" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:expr, [], ' true # this is a boolean ', %{column: 5, line: 1}},
-      {:eof, %{column: 35, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <% true # this is a boolean %>', @opts) == {:ok, exprs}
-  end
-
-  test "Elixir comments with do-end" do
-    exprs = [
-      {:start_expr, [], ' if true do # startif ', %{column: 1, line: 1}},
-      {:text, 'text', %{column: 27, line: 1}},
-      {:end_expr, [], ' end # closeif ', %{column: 31, line: 1}},
-      {:eof, %{column: 50, line: 1}}
-    ]
-
-    assert EEx.tokenize('<% if true do # startif %>text<% end # closeif %>', @opts) ==
-             {:ok, exprs}
+  test "comments with do/end" do
+    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == {:ok, [
+      {:text, 'foo bar'}
+    ]}
   end
 
   test "strings with embedded do end" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:start_expr, '', ' if true do ', %{column: 5, line: 1}},
-      {:text, 'bar', %{column: 21, line: 1}},
-      {:end_expr, '', ' end ', %{column: 24, line: 1}},
-      {:eof, %{column: 33, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <% if true do %>bar<% end %>', @opts) == {:ok, exprs}
+    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, [
+      {:text, 'foo '},
+      {:start_expr, 1, '', ' if true do '},
+      {:text, 'bar'},
+      {:end_expr, 1, '', ' end '}
+    ]}
   end
 
   test "strings with embedded -> end" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:start_expr, '', ' cond do ', %{column: 5, line: 1}},
-      {:middle_expr, '', ' false -> ', %{column: 18, line: 1}},
-      {:text, 'bar', %{column: 32, line: 1}},
-      {:middle_expr, '', ' true -> ', %{column: 35, line: 1}},
-      {:text, 'baz', %{column: 48, line: 1}},
-      {:end_expr, '', ' end ', %{column: 51, line: 1}},
-      {:eof, %{column: 60, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', @opts) ==
-             {:ok, exprs}
-  end
-
-  test "strings with fn-end with newline" do
-    exprs = [
-      {:start_expr, '=', ' a fn ->\n', %{column: 1, line: 1}},
-      {:text, 'foo', %{column: 3, line: 2}},
-      {:end_expr, [], ' end ', %{column: 6, line: 2}},
-      {:eof, %{column: 15, line: 2}}
-    ]
-
-    assert EEx.tokenize('<%= a fn ->\n%>foo<% end %>', @opts) ==
-             {:ok, exprs}
-  end
-
-  test "strings with multiple fn-end" do
-    exprs = [
-      {:start_expr, '=', ' a fn -> ', %{column: 1, line: 1}},
-      {:text, 'foo', %{column: 15, line: 1}},
-      {:middle_expr, '', ' end, fn -> ', %{column: 18, line: 1}},
-      {:text, 'bar', %{column: 34, line: 1}},
-      {:end_expr, '', ' end ', %{column: 37, line: 1}},
-      {:eof, %{column: 46, line: 1}}
-    ]
-
-    assert EEx.tokenize('<%= a fn -> %>foo<% end, fn -> %>bar<% end %>', @opts) ==
-             {:ok, exprs}
-  end
-
-  test "strings with fn-end followed by do block" do
-    exprs = [
-      {:start_expr, '=', ' a fn -> ', %{column: 1, line: 1}},
-      {:text, 'foo', %{column: 15, line: 1}},
-      {:middle_expr, '', ' end do ', %{column: 18, line: 1}},
-      {:text, 'bar', %{column: 30, line: 1}},
-      {:end_expr, '', ' end ', %{column: 33, line: 1}},
-      {:eof, %{column: 42, line: 1}}
-    ]
-
-    assert EEx.tokenize('<%= a fn -> %>foo<% end do %>bar<% end %>', @opts) == {:ok, exprs}
+    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == {:ok, [
+      {:text, 'foo '},
+      {:start_expr, 1, '', ' cond do '},
+      {:middle_expr, 1, '', ' false -> '},
+      {:text, 'bar'},
+      {:middle_expr, 1, '', ' true -> '},
+      {:text, 'baz'},
+      {:end_expr, 1, '', ' end '}
+    ]}
   end
 
   test "strings with embedded keywords blocks" do
-    exprs = [
-      {:text, 'foo ', %{column: 1, line: 1}},
-      {:start_expr, '', ' if true do ', %{column: 5, line: 1}},
-      {:text, 'bar', %{column: 21, line: 1}},
-      {:middle_expr, '', ' else ', %{column: 24, line: 1}},
-      {:text, 'baz', %{column: 34, line: 1}},
-      {:end_expr, '', ' end ', %{column: 37, line: 1}},
-      {:eof, %{column: 46, line: 1}}
-    ]
-
-    assert EEx.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', @opts) ==
-             {:ok, exprs}
+    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, [
+      {:text, 'foo '},
+      {:start_expr, 1, '', ' if true do '},
+      {:text, 'bar'},
+      {:middle_expr, 1, '', ' else '},
+      {:text, 'baz'},
+      {:end_expr, 1, '', ' end '}
+    ]}
   end
 
   test "trim mode" do
-    template = '\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  \n\n  '
-
-    exprs = [
-      {:start_expr, '=', ' if true do ', %{column: 2, line: 1}},
-      {:text, '\n TRUE \n', %{column: 20, line: 1}},
-      {:middle_expr, '', ' else ', %{column: 3, line: 3}},
-      {:text, '\n FALSE \n', %{column: 13, line: 3}},
-      {:end_expr, '', ' end ', %{column: 3, line: 5}},
-      {:eof, %{column: 3, line: 7}}
-    ]
-
-    assert EEx.tokenize(template, [trim: true] ++ @opts) == {:ok, exprs}
+    template = '\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  '
+    assert T.tokenize(template, 1, trim: true) == {:ok, [
+      {:start_expr, 1, '=', ' if true do '},
+      {:text, ' TRUE \n'},
+      {:middle_expr, 3, '', ' else '},
+      {:text, ' FALSE \n'},
+      {:end_expr, 5, '', ' end '}
+    ]}
   end
 
   test "trim mode with comment" do
-    exprs = [
-      {:text, '\n123', %{column: 19, line: 1}},
-      {:eof, %{column: 4, line: 2}}
-    ]
-
-    assert EEx.tokenize('  <%# comment %>  \n123', [trim: true] ++ @opts) == {:ok, exprs}
-  end
-
-  test "trim mode with multi-line comment" do
-    exprs = [
-      {:comment, ' comment ', %{column: 3, line: 1}},
-      {:text, '\n123', %{column: 23, line: 1}},
-      {:eof, %{column: 4, line: 2}}
-    ]
-
-    assert EEx.tokenize('  <%!-- comment --%>  \n123', [trim: true] ++ @opts) == {:ok, exprs}
+    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, [
+      {:text, '123'}
+    ]}
   end
 
   test "trim mode with CRLF" do
-    exprs = [
-      {:text, '0\n', %{column: 1, line: 1}},
-      {:expr, '=', ' 12 ', %{column: 3, line: 2}},
-      {:text, '\n34', %{column: 15, line: 2}},
-      {:eof, %{column: 3, line: 3}}
-    ]
-
-    assert EEx.tokenize('0\r\n  <%= 12 %>  \r\n34', [trim: true] ++ @opts) == {:ok, exprs}
+    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, [
+      {:text, '0\r\n'},
+      {:expr, 2, '=', ' 12 '},
+      {:text, '34'}
+    ]}
   end
 
   test "trim mode set to false" do
-    exprs = [
-      {:text, ' ', %{column: 1, line: 1}},
-      {:expr, '=', ' 12 ', %{column: 2, line: 1}},
-      {:text, ' \n', %{column: 11, line: 1}},
-      {:eof, %{column: 1, line: 2}}
-    ]
-
-    assert EEx.tokenize(' <%= 12 %> \n', [trim: false] ++ @opts) == {:ok, exprs}
+    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, [
+      {:text, ' '},
+      {:expr, 1, '=', ' 12 '},
+      {:text, ' \n'}
+    ]}
   end
 
   test "trim mode no false positives" do
-    assert_not_trimmed = fn x ->
-      assert EEx.tokenize(x, [trim: false] ++ @opts) == EEx.tokenize(x, @opts)
-    end
+    assert_not_trimmed = fn x -> assert T.tokenize(x, 1, trim: true) == T.tokenize(x, 1) end
 
     assert_not_trimmed.('foo <%= "bar" %>  ')
     assert_not_trimmed.('\n  <%= "foo" %>bar')
@@ -373,23 +156,8 @@ defmodule EEx.TokenizerTest do
     assert_not_trimmed.('  <%= 01 %><%= 23 %>\n')
   end
 
-  test "returns error when there is start mark and no end mark" do
-    assert EEx.tokenize('foo <% :bar', @opts) ==
-             {:error, "missing token '%>'", %{column: 12, line: 1}}
-
-    assert EEx.tokenize('<%# true ', @opts) ==
-             {:error, "missing token '%>'", %{column: 10, line: 1}}
-
-    assert EEx.tokenize('<%!-- foo ', @opts) ==
-             {:error, "missing token '--%>'", %{column: 11, line: 1}}
-  end
-
-  test "marks invalid expressions as regular expressions" do
-    assert EEx.tokenize('<% 1 $ 2 %>', @opts) ==
-             {:ok,
-              [
-                {:expr, [], ' 1 $ 2 ', %{column: 1, line: 1}},
-                {:eof, %{column: 12, line: 1}}
-              ]}
+  test "raise syntax error when there is start mark and no end mark" do
+    assert T.tokenize('foo <% :bar', 1) == {:error, 1, "missing token '%>'"}
+    assert T.tokenize('<%# true ', 1) == {:error, 1, "missing token '%>'"}
   end
 end

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
@@ -52,7 +55,7 @@ defmodule EExTest do
 
   describe "evaluates" do
     test "simple string" do
-      assert_eval("foo bar", "foo bar")
+      assert_eval "foo bar", "foo bar"
     end
 
     test "Unicode" do
@@ -60,48 +63,13 @@ defmodule EExTest do
         • <%= "•" %> •
         <%= "Jößé Vâlìm" %> Jößé Vâlìm
       """
-
-      assert_eval("  • • •\n  Jößé Vâlìm Jößé Vâlìm\n", template)
-    end
-
-    test "no spaces" do
-      string = """
-      <%=cond do%>
-      <%false ->%>
-        this
-      <%true ->%>
-        that
-      <%end%>
-      """
-
-      expected = "\n  that\n\n"
-      assert_eval(expected, string, [])
+      assert_eval "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n", template
     end
 
     test "trim mode" do
-      string = "<%= 123 %> \n  \n  <%= 789 %>"
-      expected = "123\n789"
-      assert_eval(expected, string, [], trim: true)
-
       string = "<%= 123 %> \n456\n  <%= 789 %>"
-      expected = "123\n456\n789"
-      assert_eval(expected, string, [], trim: true)
-
-      string = "<%= 123 %> \n\n456\n\n  <%= 789 %>"
-      expected = "123\n456\n789"
-      assert_eval(expected, string, [], trim: true)
-
-      string = "<%= 123 %> \n  \n456\n  \n  <%= 789 %>"
-      expected = "123\n456\n789"
-      assert_eval(expected, string, [], trim: true)
-
-      string = "\n  <%= 123 %> \n  <%= 456 %>  \n  <%= 789 %>  \n"
-      expected = "123\n456\n789"
-      assert_eval(expected, string, [], trim: true)
-
-      string = "\r\n  <%= 123 %> \r\n  <%= 456 %>  \r\n  <%= 789 %>  \r\n"
-      expected = "123\n456\n789"
-      assert_eval(expected, string, [], trim: true)
+      expected = "123456\n789"
+      assert_eval expected, string, [], trim: true
     end
 
     test "trim mode with middle expression" do
@@ -113,243 +81,103 @@ defmodule EExTest do
         that
       <% end %>
       """
-
-      expected = "\n  that\n"
-      assert_eval(expected, string, [], trim: true)
-    end
-
-    test "trim mode with multiple lines" do
-      string = """
-      <%= "First line" %>
-      <%= "Second line" %>
-      <%= "Third line" %>
-      <%= "Fourth line" %>
-      """
-
-      expected = "First line\nSecond line\nThird line\nFourth line"
-      assert_eval(expected, string, [], trim: true)
-    end
-
-    test "trim mode with no spaces" do
-      string = """
-      <%=if true do%>
-        this
-      <%else%>
-        that
-      <%end%>
-      """
-
-      expected = "\n  this\n"
-      assert_eval(expected, string, [], trim: true)
-
-      string = """
-      <%=cond do%>
-      <%false ->%>
-        this
-      <%true ->%>
-        that
-      <%end%>
-      """
-
-      expected = "\n  that\n"
-      assert_eval(expected, string, [], trim: true)
+      expected = "  that\n"
+      assert_eval expected, string, [], trim: true
     end
 
     test "embedded code" do
-      assert_eval("foo bar", "foo <%= :bar %>")
+      assert_eval "foo bar", "foo <%= :bar %>"
     end
 
     test "embedded code with binding" do
-      assert EEx.eval_string("foo <%= bar %>", bar: 1) == "foo 1"
+      assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
     end
 
     test "embedded code with do end when true" do
-      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 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 %>")
+      assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
     end
 
     test "embedded code with do end and expression" do
-      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 multiple expressions" do
-      assert_eval(
-        "foo bar baz",
-        "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
-      )
-
+      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 %>")
+      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 comments in do end" do
-      assert_eval("foo bar", "foo <%= case true do %><%# comment %><% true -> %>bar<% end %>")
-
-      assert_eval(
-        "foo\n\nbar\n",
-        "foo\n<%= case true do %>\n<%# comment %>\n<% true -> %>\nbar\n<% end %>"
-      )
-    end
-
-    test "embedded code with multi-line comments in do end" do
-      assert_eval("foo bar", "foo <%= case true do %><%!-- comment --%><% true -> %>bar<% end %>")
-
-      assert_eval(
-        "foo\n\nbar\n",
-        "foo\n<%= case true do %>\n<%!-- comment --%>\n<% true -> %>\nbar\n<% end %>"
-      )
+      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 %>")
+      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 %>"
-      )
+      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 ",
-        "<%= Enum.map([1, 2, 3], fn x ->\n%> <%= 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) ) %>"
-      )
+    test "embedded code 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 with variable definition" do
-      assert_eval("foo 1", "foo <% bar = 1 %><%= bar %>")
+      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], \",\" %>")
+      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 %>")
+      assert_eval "foo bar %>", "foo bar %>"
     end
   end
 
   describe "raises syntax errors" do
     test "when the token is invalid" do
-      assert_raise EEx.SyntaxError, "nofile:1:12: missing token '%>'", fn ->
-        EEx.compile_string("foo <%= bar")
+      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:18: 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:5: unexpected end of expression <% end %>", fn ->
-        EEx.compile_string("foo <% end %>")
+      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:18: unexpected end of string, expected a closing '<% end %>'"
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("foo\n<%= if true 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
 
     test "when nested end expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1:31: unexpected end of expression <% end %>", fn ->
-        EEx.compile_string("foo <%= if true do %><% end %><% end %>")
+      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 %>\"]
+        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 %>\"]
-    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
-    end
-  end
-
-  describe "error messages" do
-    test "honor line numbers" do
-      assert_raise EEx.SyntaxError, "nofile:99:12: 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:12: missing token '%>'", fn ->
-        EEx.compile_string("foo <%= bar", file: "my_file.eex")
-      end
+        EEx.compile_string "foo <%= if true do %>true<% else %>false<%= end %>"
+      end) =~ ~s[unexpected beginning of EEx tag \"<%=\" on end of expression \"<%= end %>\"]
     end
   end
 
@@ -365,7 +193,7 @@ defmodule EExTest do
       <%= __ENV__.line %>
       """
 
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "respects line numbers inside nested expressions" do
@@ -385,7 +213,7 @@ defmodule EExTest do
       <%= __ENV__.line %>
       """
 
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "respects line numbers inside start expression" do
@@ -405,7 +233,7 @@ defmodule EExTest do
       <%= __ENV__.line %>
       """
 
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "respects line numbers inside middle expression with ->" do
@@ -427,7 +255,7 @@ defmodule EExTest do
       <%= __ENV__.line %>
       """
 
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "respects line number inside middle expressions with keywords" do
@@ -449,11 +277,11 @@ defmodule EExTest do
       <%= __ENV__.line %>
       """
 
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "respects files" do
-      assert_eval("sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex")
+      assert_eval "sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex"
     end
   end
 
@@ -475,53 +303,7 @@ defmodule EExTest do
       <% end %>
       """
 
-      assert_eval(expected, string)
-    end
-
-    test "inside multiple functions" do
-      expected = """
-
-      A 1
-
-      B 2
-
-      A 3
-
-      """
-
-      string = """
-      <%= #{__MODULE__}.switching_map [1, 2, 3], fn x -> %>
-      A <%= x %>
-      <% end, fn x -> %>
-      B <%= x %>
-      <% end %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "inside callback and do block" do
-      expected = """
-
-
-      A 1
-
-      B 2
-
-      A 3
-
-      """
-
-      string = """
-      <% require #{__MODULE__} %>
-      <%= #{__MODULE__}.switching_macro [1, 2, 3], fn x -> %>
-      A <%= x %>
-      <% end do %>
-      B <%= x %>
-      <% end %>
-      """
-
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "inside cond" do
@@ -541,7 +323,7 @@ defmodule EExTest do
       <% end %>
       """
 
-      assert_eval(expected, string)
+      assert_eval expected, string
     end
 
     test "inside cond with do end" do
@@ -551,59 +333,35 @@ defmodule EExTest do
        <% "a" in y -> %>
         Good
        <% true -> %>
-        <%= if true do %>true<% else %>false<% end %>
+        <% if true do %>true<% else %>false<% end %>
         Bad
       <% end %>
       """
 
-      assert_eval("\n\n  Good\n \n", string)
-    end
-
-    test "line and column meta" do
-      parser_options = Code.get_compiler_option(:parser_options)
-      Code.put_compiler_option(:parser_options, columns: true)
-
-      try do
-        indentation = 12
-
-        ast =
-          EEx.compile_string(
-            """
-            <%= f() %> <% f() %>
-              <%= f fn -> %>
-                <%= f() %>
-              <% end %>
-            """,
-            indentation: indentation
-          )
-
-        {_, calls} =
-          Macro.prewalk(ast, [], fn
-            {:f, meta, _args} = expr, acc -> {expr, [meta | acc]}
-            other, acc -> {other, acc}
-          end)
-
-        assert Enum.reverse(calls) == [
-                 [line: 1, column: indentation + 5],
-                 [line: 1, column: indentation + 15],
-                 [line: 2, column: indentation + 7],
-                 [line: 3, column: indentation + 9]
-               ]
-      after
-        Code.put_compiler_option(:parser_options, parser_options)
-      end
+      assert_eval "\n\n  Good\n \n", string
     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)
+      assert_eval "\ndone\n", string, packages: nil, all: nil
     end
   end
 
@@ -611,19 +369,17 @@ defmodule EExTest 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)
+      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)
+      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 ->
+      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
@@ -631,49 +387,48 @@ defmodule EExTest do
 
     test "sets external resource attribute" do
       assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
-               [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
-    end
-
-    test "supports t:Path.t() paths" do
-      filename = to_charlist(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
-
-    assert_raise EEx.SyntaxError, "my_file.eex:1:12: missing token '%>'", fn ->
-      EEx.compile_string("foo <%= bar", file: "my_file.eex")
-    end
-
-    test "supports overriding file and line through options" do
-      filename = Path.join(__DIR__, "fixtures/eex_template_with_syntax_error.eex")
-
-      assert_raise EEx.SyntaxError, "my_file.eex:11:1: missing token '%>'", fn ->
-        EEx.eval_file(filename, _bindings = [], file: "my_file.eex", line: 10)
-      end
+             [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
     end
   end
 
   describe "precompiled" do
+
     test "from string" do
       assert EExTest.Compiled.string_sample(1, 2) == "3"
     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))
+      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 "from file does not affect backtrace" do
-      file = to_charlist(Path.relative_to_cwd(__ENV__.file))
+      assert EExTest.Compiled.before_compile ==
+        {8,
+          {EExTest.Compiled,
+            :before_compile,
+            0,
+            [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 7]
+         }
+       }
 
-      assert EExTest.Compiled.before_compile() ==
-               {7, {EExTest.Compiled, :before_compile, 0, [file: file, line: 7]}}
+      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.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]}}
+      assert EExTest.Compiled.unknown ==
+        {29,
+          {EExTest.Compiled,
+            :unknown,
+            0,
+            [file: 'unknown', line: 28]
+         }
+       }
     end
   end
 
@@ -681,31 +436,15 @@ defmodule EExTest do
     @behaviour EEx.Engine
 
     def init(_opts) do
-      "INIT"
+      ""
     end
 
     def handle_body(body) do
-      "BODY(#{body})"
+      {:wrapped, body}
     end
 
-    def handle_begin(_) do
-      "BEGIN"
-    end
-
-    def handle_end(buffer) do
-      buffer <> ":END"
-    end
-
-    def handle_text(buffer, meta, text) do
-      buffer <> ":TEXT-#{meta[:line]}-#{meta[:column]}(#{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)})"
+    def handle_text(buffer, text) do
+      EEx.Engine.handle_text(buffer, text)
     end
 
     def handle_expr(buffer, mark, expr) do
@@ -714,45 +453,13 @@ defmodule EExTest do
   end
 
   describe "custom engines" do
-    test "text" do
-      assert_eval("BODY(INIT:TEXT-1-1(foo))", "foo", [], engine: TestEngine)
-    end
-
-    test "custom marker" do
-      assert_eval("BODY(INIT:TEXT-1-1(foo):DIV(:bar))", "foo <%/ :bar %>", [], engine: TestEngine)
-    end
-
-    test "begin/end" do
-      assert_eval(
-        ~s[BODY(INIT:TEXT-1-1(foo):EQUAL(if do\n  "BEGIN:TEXT-1-17(this):END"\nelse\n  "BEGIN:TEXT-1-31(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
-  end
-
-  describe "parser options" do
-    test "customizes parsed code" do
-      atoms_encoder = fn "not_jose", _ -> {:ok, :jose} end
-
-      assert_eval("valid", "<%= not_jose %>", [jose: "valid"],
-        parser_options: [static_atoms_encoder: atoms_encoder]
-      )
+    test "calls handle_body" do
+      assert {:wrapped, "foo"} = EEx.eval_string("foo", [], engine: TestEngine)
     end
   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
@@ -760,27 +467,4 @@ defmodule EExTest do
   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/fixtures/eex_template_with_syntax_error.eex

@@ -1 +0,0 @@
-foo <%= bar

lib/eex/test/test_helper.exs

@@ -1,8 +1 @@
-{line_exclude, line_include} =
-  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
-
-ExUnit.start(
-  trace: !!System.get_env("TRACE"),
-  include: line_include,
-  exclude: line_exclude
-)
+ExUnit.start [trace: "--trace" in System.argv]

lib/elixir/diff.exs

@@ -1,156 +0,0 @@
-defmodule Diff do
-  @moduledoc """
-  Utilities for comparing build artifacts.
-  """
-
-  @known_chunks ~w(
-    abstract_code
-    debug_info
-    attributes
-    compile_info
-    exports
-    labeled_exports
-    imports
-    indexed_imports
-    locals
-    labeled_locals
-    atoms
-  )a
-
-  @doc """
-  Compares the build artifacts of two build directories.
-  """
-  @spec compare_dirs(Path.t(), Path.t()) ::
-          {
-            only1_paths :: list(Path.t()),
-            only2_paths :: list(Path.t()),
-            diff :: list({Path.t(), diff :: String.t()})
-          }
-  def compare_dirs(dir1, dir2) do
-    dir1 = Path.expand(dir1)
-    dir2 = Path.expand(dir2)
-
-    assert_dir!(dir1)
-    assert_dir!(dir2)
-
-    dir1_paths = relative_paths(dir1)
-    dir2_paths = relative_paths(dir2)
-
-    only1_paths = dir1_paths -- dir2_paths
-    only2_paths = dir2_paths -- dir1_paths
-    common_paths = dir1_paths -- only1_paths
-    common_files = Enum.reject(common_paths, &File.dir?/1)
-
-    diff =
-      Enum.flat_map(common_files, fn path ->
-        file1 = Path.join(dir1, path)
-        file2 = Path.join(dir2, path)
-
-        case compare_files(file1, file2) do
-          :eq -> []
-          {:diff, diff} -> [{path, diff}]
-        end
-      end)
-
-    {only1_paths, only2_paths, diff}
-  end
-
-  @doc """
-  Compares the contents of two files.
-
-  If the files are BEAM files, it performs a more human-friendly
-  "BEAM-diff".
-  """
-  @spec compare_files(Path.t(), Path.t()) :: :eq | {:diff, diff :: String.t()}
-  def compare_files(file1, file2) do
-    content1 = File.read!(file1)
-    content2 = File.read!(file2)
-
-    if content1 == content2 do
-      :eq
-    else
-      diff =
-        if String.ends_with?(file1, ".beam") do
-          beam_diff(file1, content1, file2, content2)
-        else
-          file_diff(file1, file2)
-        end
-
-      {:diff, diff}
-    end
-  end
-
-  defp beam_diff(file1, content1, file2, content2) do
-    with {:ok, {module, chunks1}} <- :beam_lib.chunks(content1, @known_chunks),
-         {:ok, {^module, chunks2}} <- :beam_lib.chunks(content2, @known_chunks),
-         true <- chunks1 != chunks2 do
-      for {chunk1, chunk2} <- Enum.zip(chunks1, chunks2), chunk1 != chunk2 do
-        tmp_file1 =
-          chunk1
-          |> inspect(pretty: true, limit: :infinity)
-          |> write_tmp()
-
-        tmp_file2 =
-          chunk2
-          |> inspect(pretty: true, limit: :infinity)
-          |> write_tmp()
-
-        file_diff(tmp_file1, tmp_file2)
-      end
-    else
-      _ ->
-        file_diff(file1, file2)
-    end
-  end
-
-  defp file_diff(file1, file2) do
-    {diff, _} = System.cmd("diff", [file1, file2])
-    diff
-  end
-
-  defp relative_paths(dir) do
-    dir
-    |> Path.join("**")
-    |> Path.wildcard()
-    |> Enum.map(&Path.relative_to(&1, dir))
-  end
-
-  defp assert_dir!(dir) do
-    unless File.dir?(dir) do
-      raise ArgumentError, "#{inspect(dir)} is not a directory"
-    end
-  end
-
-  defp write_tmp(content) do
-    filename = generate_tmp_filename()
-    File.mkdir_p!("tmp")
-    File.write!(Path.join("tmp", filename), content)
-    Path.join("tmp", filename)
-  end
-
-  defp generate_tmp_filename do
-    sec = :os.system_time(:second)
-    rand = :rand.uniform(999_999_999)
-    scheduler_id = :erlang.system_info(:scheduler_id)
-    "tmp-#{sec}-#{rand}-#{scheduler_id}"
-  end
-end
-
-case System.argv() do
-  [dir1, dir2] ->
-    case Diff.compare_dirs(dir1, dir2) do
-      {[], [], []} ->
-        IO.puts("#{inspect(dir1)} and #{inspect(dir2)} are equal")
-
-      {only1, only2, diff} ->
-        for path <- only1, do: IO.puts("Only in #{dir1}: #{path}")
-        for path <- only2, do: IO.puts("Only in #{dir2}: #{path}")
-        for {path, diff} <- diff, do: IO.puts("Diff #{path}:\n#{diff}")
-
-        System.halt(1)
-    end
-
-  _ ->
-    IO.puts("Please, provide two directories as arguments")
-    System.halt(1)
-end

lib/elixir/docs.exs

@@ -1,118 +0,0 @@
-# Returns config for Elixir docs
-
-canonical = System.fetch_env!("CANONICAL")
-
-[
-  extras: Path.wildcard("lib/elixir/pages/*.md") ++ ["CHANGELOG.md"],
-  deps: [
-    eex: "https://hexdocs.pm/eex/#{canonical}",
-    ex_unit: "https://hexdocs.pm/ex_unit/#{canonical}",
-    iex: "https://hexdocs.pm/iex/#{canonical}",
-    logger: "https://hexdocs.pm/logger/#{canonical}",
-    mix: "https://hexdocs.pm/mix/#{canonical}"
-  ],
-  groups_for_functions: [
-    Guards: &(&1[:guard] == true)
-  ],
-  skip_undefined_reference_warnings_on: ["lib/elixir/pages/compatibility-and-deprecations.md"],
-  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,
-      PartitionSupervisor,
-      Process,
-      Registry,
-      Supervisor,
-      Task,
-      Task.Supervisor
-    ],
-    Protocols: [
-      Collectable,
-      Enumerable,
-      Inspect,
-      Inspect.Algebra,
-      Inspect.Opts,
-      List.Chars,
-      Protocol,
-      String.Chars
-    ],
-    "Code & Macros": [
-      Code,
-      Code.Fragment,
-      Kernel.ParallelCompiler,
-      Macro,
-      Macro.Env
-    ]
-
-    ## Automatically detected groups
-
-    # 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. Keywords supports only atoms keys, keys for maps can
-  be of any type. Both return `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,90 +31,129 @@ 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 (`data[key]`) 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 (which is not supposed to happen if the keys are
-  > predefined). Similarly, since structs are maps and structs
-  > have predefined keys, 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`
+  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.
+
+  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 map with `:name` and `:languages` keys, here is how
+  to deeply traverse the map and convert all language names to uppercase:
 
       iex> languages = [
       ...>   %{name: "elixir", type: :functional},
-      ...>   %{name: "c", type: :procedural}
+      ...>   %{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}
-        ]
-      }
+      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` behaviour 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 t :: container | nil_container | any
+  @type any_container :: any
+  @type t :: container | nil_container | any_container
   @type key :: any
   @type value :: any
 
-  @type get_fun(data) ::
-          (:get, data, (term -> term) -> new_data :: container)
+  @type get_fun(data, get_value) ::
+        (:get, data, (term -> term) ->
+        {get_value, new_data :: container})
 
-  @type get_and_update_fun(data, current_value) ::
-          (:get_and_update, data, (term -> term) ->
-             {current_value, new_data :: container} | :pop)
+  @type get_and_update_fun(data, get_value) ::
+        (:get_and_update, data, (term -> term) ->
+        {get_value, new_data :: container} | :pop)
 
-  @type access_fun(data, current_value) ::
-          get_fun(data) | get_and_update_fun(data, current_value)
+  @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`.
@@ -127,21 +174,40 @@ defmodule Access do
   """
   @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 `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 examples of
+  how to implement this callback.
+  """
+  @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 `{current_value, new_value}` or `:pop`.
+  This function must return either `{get_value, update_value}` or `:pop`.
 
-  If the passed function returns `{current_value, new_value}`,
-  the return value of this callback should be `{current_value, new_data}`, where:
-
-    * `current_value` is the retrieved value (which can be operated on before being returned)
-
-    * `new_value` is the new value to be stored under `key`
-
-    * `new_data` is `data` after updating the value of `key` with `new_value`.
+  If the passed function returns `{get_value, update_value}`,
+  the return value of this callback should be `{get_value, new_data}`, where:
+  - `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`
@@ -150,9 +216,8 @@ defmodule Access do
   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 | nil -> {current_value, new_value :: value} | :pop)) ::
-              {current_value, new_data :: data}
-            when current_value: value, data: container
+  @callback get_and_update(data, key, (value -> {get_value, value} | :pop)) ::
+            {get_value, data} when get_value: var, data: container | any_container
 
   @doc """
   Invoked to "pop" the value under `key` out of the given data structure.
@@ -166,25 +231,19 @@ defmodule Access do
 
   See the implementations for `Map.pop/3` or `Keyword.pop/3` for more examples.
   """
-  @callback pop(data, key) :: {value, data} when data: container
+  @callback pop(data, key) :: {value, data} when data: container | any_container
 
-  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. " <>
-                "If you are using get_in/put_in/update_in, you can specify the field " <>
-                "to be accessed using Access.key!/1"
-
-            %{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
 
@@ -194,25 +253,16 @@ defmodule Access do
 
   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
   def fetch(container, key)
 
-  def fetch(%module{} = container, key) do
-    module.fetch(container, key)
+  def fetch(%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
@@ -231,64 +281,30 @@ defmodule Access do
 
   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
+  def get(%{__struct__: struct} = container, key, default) do
     try do
-      module.fetch(container, key)
+      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], _}
     else
       {:ok, value} -> value
       :error -> default
@@ -311,7 +327,7 @@ defmodule Access do
 
   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)
+      "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
   end
 
   def get(nil, _key, default) do
@@ -323,37 +339,24 @@ defmodule Access do
   a 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 `{current_value, new_value}`:
-  the "get" value `current_value` (the retrieved value, which can be operated on before
-  being returned) and the new value to be stored under `key` (`new_value`).
+  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.
 
   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 | nil -> {current_value, new_value :: value} | :pop)) ::
-          {current_value, new_data :: data}
-        when current_value: var, data: container
+  @spec get_and_update(data, key, (value -> {get_value, value} | :pop)) ::
+        {get_value, data} when get_value: var, data: container
   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
@@ -365,7 +368,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 """
@@ -395,11 +399,11 @@ defmodule Access do
 
   """
   @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
@@ -411,7 +415,8 @@ 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
@@ -425,8 +430,8 @@ 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, %{}), Access.key(:name, "meg")])
-      "meg"
+      iex> get_in(%{}, [Access.key(:user, %{}), Access.key(:name)])
+      nil
 
   Such is also useful when using update functions, allowing us to introduce
   values as we traverse the data structure for updates:
@@ -439,8 +444,8 @@ 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)])
@@ -448,19 +453,20 @@ defmodule Access do
 
   An error is raised if the accessed structure is not a map or a struct:
 
+      iex> get_in(nil, [Access.key(:foo)])
+      ** (BadMapError) expected a map, got: nil
+
       iex> get_in([], [Access.key(:foo)])
       ** (BadMapError) expected a map, got: []
 
   """
-  @spec key(key, term) :: access_fun(data :: struct | map, current_value :: term)
+  @spec key(key, term) :: access_fun(data :: struct | map, get_value :: term)
   def key(key, default \\ nil) 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 +480,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.
+  The returned function 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 +502,19 @@ defmodule Access do
       ** (RuntimeError) Access.key!/1 expected a map/struct, got: []
 
   """
-  @spec key!(key) :: access_fun(data :: struct | map, current_value :: term)
+  @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
 
@@ -523,16 +526,13 @@ defmodule Access do
 
   The returned function raises if `index` is out of bounds.
 
-  Note that popping elements out of tuples is not possible and raises an
-  error.
-
   ## 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 +544,21 @@ defmodule Access do
       ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}
 
   """
-  @spec elem(non_neg_integer) :: access_fun(data :: tuple, current_value :: term)
-  def elem(index) when is_integer(index) and index >= 0 do
+  @spec elem(non_neg_integer) :: access_fun(data :: tuple, get_value :: term)
+  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,8 +573,8 @@ 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])
@@ -587,8 +584,8 @@ defmodule Access do
   numbers and multiplying 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 +595,7 @@ defmodule Access do
       ** (RuntimeError) Access.all/0 expected a list, got: %{}
 
   """
-  @spec all() :: access_fun(data :: list, current_value :: list)
+  @spec all() :: access_fun(data :: list, get_value :: list)
   def all() do
     &all/3
   end
@@ -612,7 +609,7 @@ defmodule Access do
   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 +634,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 +653,25 @@ 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, current_value :: term)
-  def at(index) when is_integer(index) do
-    fn op, data, next -> at(op, data, index, next) end
+  @spec at(non_neg_integer) :: access_fun(data :: list, get_value :: term)
+  def at(index) when is_integer(index) and 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
@@ -683,264 +679,25 @@ defmodule Access do
   end
 
   defp at(:get_and_update, data, index, next) when is_list(data) do
-    get_and_update_at(data, index, next, [], fn -> nil end)
+    get_and_update_at(data, index, next, [])
   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, _default_fun) do
+  defp get_and_update_at([head | rest], 0, next, updates) do
     case next.(head) do
       {get, update} -> {get, :lists.reverse([update | updates], rest)}
       :pop -> {head, :lists.reverse(updates, rest)}
     end
   end
 
-  defp get_and_update_at([_ | _] = list, index, next, updates, default_fun) when index < 0 do
-    list_length = length(list)
-
-    if list_length + index >= 0 do
-      get_and_update_at(list, list_length + index, next, updates, default_fun)
-    else
-      {default_fun.(), list}
-    end
+  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([head | rest], index, next, updates, default_fun) when index > 0 do
-    get_and_update_at(rest, index - 1, next, [head | updates], default_fun)
-  end
-
-  defp get_and_update_at([], _index, _next, updates, default_fun) do
-    {default_fun.(), :lists.reverse(updates)}
-  end
-
-  @doc ~S"""
-  Same as `at/1` except that it raises `Enum.OutOfBoundsError`
-  if the given index is out of bounds.
-
-  ## Examples
-
-      iex> get_in([:a, :b, :c], [Access.at!(2)])
-      :c
-      iex> get_in([:a, :b, :c], [Access.at!(3)])
-      ** (Enum.OutOfBoundsError) out of bounds error
-
-  """
-  @doc since: "1.11.0"
-  @spec at!(integer) :: access_fun(data :: list, current_value :: term)
-  def at!(index) when is_integer(index) do
-    fn op, data, next -> at!(op, data, index, next) end
-  end
-
-  defp at!(:get, data, index, next) when is_list(data) do
-    case Enum.fetch(data, index) do
-      {:ok, value} -> next.(value)
-      :error -> raise Enum.OutOfBoundsError
-    end
-  end
-
-  defp at!(:get_and_update, data, index, next) when is_list(data) do
-    get_and_update_at(data, index, next, [], fn -> raise Enum.OutOfBoundsError end)
-  end
-
-  defp at!(_op, data, _index, _next) do
-    raise "Access.at!/1 expected a list, got: #{inspect(data)}"
-  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, current_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
-
-  @doc ~S"""
-  Returns a function that accesses all items of a list that are within the provided range.
-
-  The range will be normalized following the same rules from `Enum.slice/2`.
-
-  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}, %{name: "vitor", salary: 25}]
-      iex> get_in(list, [Access.slice(1..2), :name])
-      ["francine", "vitor"]
-      iex> get_and_update_in(list, [Access.slice(1..3//2), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {["francine"], [%{name: "john", salary: 10}, %{name: "FRANCINE", salary: 30}, %{name: "vitor", salary: 25}]}
-
-  `slice/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}, %{name: "vitor", salary: 25}]
-      iex> pop_in(list, [Access.slice(-2..-1)])
-      {[%{name: "francine", salary: 30}, %{name: "vitor", salary: 25}], [%{name: "john", salary: 10}]}
-      iex> pop_in(list, [Access.slice(-2..-1), :name])
-      {["francine", "vitor"], [%{name: "john", salary: 10}, %{salary: 30}, %{salary: 25}]}
-
-  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}, %{name: "vitor", salary: 25}]
-      iex> get_in(list, [Access.slice(5..10//2), :name])
-      []
-      iex> get_and_update_in(list, [Access.slice(5..10//2), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}, %{name: "vitor", salary: 25}]}
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.slice(2..10//3)])
-      ** (ArgumentError) Access.slice/1 expected a list, got: %{}
-
-  An error is raised if the step of the range is negative:
-
-      iex> get_in([], [Access.slice(2..10//-1)])
-      ** (ArgumentError) Access.slice/1 does not accept ranges with negative steps, got: 2..10//-1
-
-  """
-  @doc since: "1.14"
-  @spec slice(Range.t()) :: access_fun(data :: list, current_value :: list)
-  def slice(%Range{} = range) do
-    if range.step > 0 do
-      fn op, data, next -> slice(op, data, range, next) end
-    else
-      raise ArgumentError,
-            "Access.slice/1 does not accept ranges with negative steps, got: #{inspect(range)}"
-    end
-  end
-
-  defp slice(:get, data, %Range{} = range, next) when is_list(data) do
-    data
-    |> Enum.slice(range)
-    |> Enum.map(next)
-  end
-
-  defp slice(:get_and_update, data, range, next) when is_list(data) do
-    range = normalize_range(range, data)
-
-    if range.first > range.last do
-      {[], data}
-    else
-      get_and_update_slice(data, range, next, [], [], 0)
-    end
-  end
-
-  defp slice(_op, data, _range, _next) do
-    raise ArgumentError, "Access.slice/1 expected a list, got: #{inspect(data)}"
-  end
-
-  defp normalize_range(%Range{first: first, last: last, step: step}, list)
-       when first < 0 or last < 0 do
-    count = length(list)
-    first = if first >= 0, do: first, else: Kernel.max(first + count, 0)
-    last = if last >= 0, do: last, else: last + count
-    Range.new(first, last, step)
-  end
-
-  defp normalize_range(range, _list), do: range
-
-  defp get_and_update_slice([head | rest], range, next, updates, gets, index) do
-    if index in range do
-      case next.(head) do
-        :pop ->
-          get_and_update_slice(rest, range, next, updates, [head | gets], index + 1)
-
-        {get, update} ->
-          get_and_update_slice(
-            rest,
-            range,
-            next,
-            [update | updates],
-            [get | gets],
-            index + 1
-          )
-      end
-    else
-      get_and_update_slice(rest, range, next, [head | updates], gets, index + 1)
-    end
-  end
-
-  defp get_and_update_slice([], _range, _next, updates, gets, _index) do
-    {:lists.reverse(gets), :lists.reverse(updates)}
+  defp get_and_update_at([], _index, _next, updates) do
+    {nil, :lists.reverse(updates)}
   end
 end

lib/elixir/lib/agent.ex

@@ -11,50 +11,44 @@ defmodule Agent do
 
   ## 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
+      defmodule Mix.TasksServer do
         use Agent
 
-        def start_link(initial_value) do
-          Agent.start_link(fn -> initial_value end, name: __MODULE__)
+        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.
+  Agents provide a segregation between the client and server APIs (similar
+  to GenServers). In particular, the anonymous functions given to the `Agent`
+  are executed 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.
 
   Consider these two examples:
 
@@ -65,7 +59,7 @@ 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
@@ -79,60 +73,20 @@ defmodule Agent do
   than in the server can lead to race conditions if multiple clients are trying
   to update the same state to different values.
 
-  ## How to supervise
+  Finally note `use Agent` defines a `child_spec/1` function, allowing the
+  defined module to be put under a supervision tree. The generated
+  `child_spec/1` can be customized with the following options:
 
-  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
+    * `:id` - the child specification id, defauts to the current module
+    * `:start` - how to start the child process (defaults to calling `__MODULE__.start_link/1`)
     * `: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
+    * `:shutdown` - how to shut down the child
 
   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.
+  See the `Supervisor` docs for more information.
 
   ## Name registration
 
@@ -185,12 +139,7 @@ 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"
+  @doc false
   def child_spec(arg) do
     %{
       id: Agent,
@@ -201,21 +150,17 @@ defmodule Agent do
   @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
+      spec = [
+        id: opts[:id] || __MODULE__,
+        start: Macro.escape(opts[:start]) || quote(do: {__MODULE__, :start_link, [arg]}),
+        restart: opts[:restart] || :permanent,
+        shutdown: opts[:shutdown] || 5000,
+        type: :worker
+      ]
 
+      @doc false
       def child_spec(arg) do
-        default = %{
-          id: __MODULE__,
-          start: {__MODULE__, :start_link, [arg]}
-        }
-
-        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
+        %{unquote_splicing(spec)}
       end
 
       defoverridable child_spec: 1
@@ -227,9 +172,9 @@ defmodule Agent do
 
   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 `fun` is invoked and its return
+  value is used as the agent state. Note that `start_link/2` does not return
+  until the given function has returned.
 
   ## Options
 
@@ -241,7 +186,7 @@ defmodule Agent do
   and the start function will return `{:error, :timeout}`.
 
   If the `:debug` option is present, the corresponding function in the
-  [`:sys` module](`:sys`) will be invoked.
+  [`:sys` module](http://www.erlang.org/doc/man/sys.html) will be invoked.
 
   If the `:spawn_opt` option is present, its value will be passed as options
   to the underlying process as in `Process.spawn/4`.
@@ -266,7 +211,7 @@ defmodule Agent do
       %RuntimeError{message: "oops"}
 
   """
-  @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
@@ -278,7 +223,7 @@ defmodule Agent do
   instead of an anonymous function; `fun` in `module` will be called with the
   given arguments `args` to initialize the state.
   """
-  @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
@@ -291,11 +236,11 @@ defmodule Agent do
   ## Examples
 
       iex> {:ok, pid} = Agent.start(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state 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
@@ -305,7 +250,7 @@ defmodule Agent do
 
   See `start_link/4` for more information.
   """
-  @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
@@ -423,15 +368,6 @@ defmodule Agent do
   Same as `update/3` but a module, function, and arguments 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
-
   """
   @spec update(agent, module, atom, [term], timeout) :: :ok
   def update(agent, module, fun, args, timeout \\ 5000) do
@@ -447,15 +383,6 @@ defmodule Agent do
 
   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
-
   """
   @spec cast(agent, (state -> state)) :: :ok
   def cast(agent, fun) when is_function(fun, 1) do
@@ -468,15 +395,6 @@ defmodule Agent do
   Same as `cast/2` but a module, function, and arguments 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
-
   """
   @spec cast(agent, module, atom, [term]) :: :ok
   def cast(agent, module, fun, args) do

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,301 +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 life cycle. 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` and `config/runtime.exs` files. The
-  former is loaded at build-time, before your code compiles, and the latter at
-  runtime, just before your app starts. 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
 
-  See the "Configuration" section in the `Mix` module for more information.
-  You can also change the application environment dynamically by using functions
-  such as `put_env/3` and `delete_env/2`.
-
-  > Note: The config files `config/config.exs` and `config/runtime.exs`
-  > are rarely used by libraries. Libraries typically define their environment
-  > in the `def application` function of their `mix.exs`. Configuration files
-  > are rather used by applications to configure their libraries.
-
-  > Note: Each application is responsible for its own environment. Do not
-  > use the functions in this module for directly accessing or modifying
-  > the environment of other applications. Whenever you change the application
-  > environment, Elixir's build tool will only recompile the files that
-  > belong to that application. So if you read the application environment
-  > of another application, there is a chance you will be depending on
-  > outdated configuration, as your file won't be recompiled as it changes.
-
-  ## 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. However, if you try to access
-  `Application.fetch_env!/2` outside of a function:
-
-      defmodule MyApp.DBClient do
-        @db_host Application.fetch_env!(:my_app, :db_host)
-
-        def start_link() do
-          SomeLib.DBClient.start_link(host: @db_host)
-        end
-      end
-
-  You might see warnings and errors:
-
-      warning: Application.fetch_env!/2 is discouraged in the module body,
-      use Application.compile_env/3 instead
-        iex:3: MyApp.DBClient
-
-      ** (ArgumentError) could not fetch application environment :db_host
-      for application :my_app because the application was not loaded nor
-      configured
-
-  This happens because, when defining modules, the application environment
-  is not yet available. Luckily, the warning tells us how to solve this
-  issue, by using `Application.compile_env/3` instead:
-
-      defmodule MyApp.DBClient do
-        @db_host Application.compile_env(:my_app, :db_host, "db.local")
-
-        def start_link() do
-          SomeLib.DBClient.start_link(host: @db_host)
-        end
-      end
-
-  The difference here is that `compile_env` expects the default value to be
-  given as an argument, instead of using the `def application` function of
-  your `mix.exs`. Furthermore, 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.
-
-  In any case, compile-time environments should be avoided. Whenever possible,
-  reading the application environment at runtime should be the first choice.
-
-  ## 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.
+  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.
 
-  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*](https://www.erlang.org/doc/man/application.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 life cycle
-
-  ### 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 is 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` Erlang module](`:application`), and the
-  [Applications](https://www.erlang.org/doc/design_principles/applications.html)
-  section of the [OTP Design Principles User's
-  Guide](https://www.erlang.org/doc/design_principles/users_guide.html).
+  An application without a supervision tree doesn't define an application
+  module callback in the application definition in `mix.exs` file. Even though
+  there is no module with application callbacks such as `start/2` and
+  `stop/1`, the application can be started and stopped the same way as an
+  application with a supervision tree.
   """
 
   @doc """
@@ -322,7 +119,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`
@@ -334,30 +131,20 @@ 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`.
@@ -365,7 +152,7 @@ defmodule Application do
   @callback stop(state) :: term
 
   @doc """
-  Starts an application in synchronous phases.
+  Start 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
@@ -373,20 +160,10 @@ defmodule Application do
   in the order they are listed in.
   """
   @callback start_phase(phase :: term, start_type, phase_args :: term) ::
-              :ok | {:error, reason :: 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
+  @optional_callbacks start_phase: 3
 
   @doc false
   defmacro __using__(_) do
@@ -402,46 +179,30 @@ defmodule Application do
     end
   end
 
-  @application_keys [
-    :description,
-    :id,
-    :vsn,
-    :modules,
-    :maxP,
-    :maxT,
-    :registered,
-    :included_applications,
-    :optional_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
 
@@ -452,8 +213,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
@@ -479,208 +240,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.
-  """
-  @doc since: "1.10.0"
-  @spec compile_env(app, key | list, value) :: value
-  defmacro compile_env(app, key_or_path, default \\ nil) do
-    if __CALLER__.function do
-      raise "Application.compile_env/3 cannot be called inside functions, only in the module body"
-    end
-
-    key_or_path = Macro.expand_literals(key_or_path, %{__CALLER__ | function: {:__info__, 1}})
-
-    quote do
-      Application.compile_env(__ENV__, unquote(app), unquote(key_or_path), unquote(default))
-    end
-  end
-
-  @doc """
-  Reads the application environment at compilation time from a macro.
-
-  Typically, developers will use `compile_env/3`. This function must
-  only be invoked from macros which aim to read the compilation environment
-  dynamically.
-
-  It expects a `Macro.Env` as first argument, where the `Macro.Env` is
-  typically the `__CALLER__` in a macro. It raises if `Macro.Env` comes
-  from a function.
-  """
-  @doc since: "1.14.0"
-  @spec compile_env(Macro.Env.t(), app, key | list, value) :: value
-  def compile_env(%Macro.Env{} = env, app, key_or_path, default) 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) do
-    if __CALLER__.function do
-      raise "Application.compile_env!/2 cannot be called inside functions, only in the module body"
-    end
-
-    key_or_path = Macro.expand_literals(key_or_path, %{__CALLER__ | function: {:__info__, 1}})
-
-    quote do
-      Application.compile_env!(__ENV__, unquote(app), unquote(key_or_path))
-    end
-  end
-
-  @doc """
-  Reads the application environment at compilation time from a macro
-  or raises.
-
-  Typically, developers will use `compile_env!/2`. This function must
-  only be invoked from macros which aim to read the compilation environment
-  dynamically.
-
-  It expects a `Macro.Env` as first argument, where the `Macro.Env` is
-  typically the `__CALLER__` in a macro. It raises if `Macro.Env` comes
-  from a function.
-  """
-  @doc since: "1.14.0"
-  @spec compile_env!(Macro.Env.t(), app, key | list) :: value
-  def compile_env!(%Macro.Env{} = env, app, key_or_path) 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)
-  end
-
-  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:** you must use this function to read only your own application
-  > environment. Do not read the environment of other applications.
-
-  > **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.md).
-
-  ## 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
-  `Application.get_env(:my_app, :my_app_databases, [])` to retrieve the list of
-  databases (specified by module names).
-
-  The engine can then traverse each repository in the list and call
-  `Application.get_env(:my_app, Databases.RepoOne)` and so forth to retrieve the
-  configuration of each one. In this case, each configuration will be a keyword
-  list, so you can use the functions in the `Keyword` module or even the `Access`
-  module to traverse it, for example:
-
-      config = Application.get_env(:my_app, Databases.RepoOne)
-      config[:ip]
-
   """
   @spec get_env(app, key, value) :: value
-  def get_env(app, key, default \\ nil) when is_atom(app) do
-    maybe_warn_on_app_env_key(app, key)
+  def get_env(app, key, default \\ nil) do
     :application.get_env(app, key, default)
   end
 
@@ -688,19 +259,9 @@ defmodule Application do
   Returns the value for `key` in `app`'s environment in a tuple.
 
   If the configuration parameter does not exist, the function returns `:error`.
-
-  > **Important:** you must use this function to read only your own application
-  > environment. Do not read the environment of other applications.
-
-  > **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.md).
   """
   @spec fetch_env(app, key) :: {:ok, value} | :error
-  def fetch_env(app, key) when is_atom(app) do
-    maybe_warn_on_app_env_key(app, key)
-
+  def fetch_env(app, key) do
     case :application.get_env(app, key) do
       {:ok, value} -> {:ok, value}
       :undefined -> :error
@@ -711,37 +272,15 @@ defmodule Application do
   Returns the value for `key` in `app`'s environment.
 
   If the configuration parameter does not exist, raises `ArgumentError`.
-
-  > **Important:** you must use this function to read only your own application
-  > environment. Do not read the environment of other applications.
-
-  > **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.md).
   """
-  @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 nor configured"
+          "application #{inspect app} is not loaded, " <>
+          "or the configuration parameter #{inspect key} is not set"
     end
   end
 
@@ -757,55 +296,26 @@ defmodule Application do
   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
-    maybe_warn_on_app_env_key(app, key)
+  @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
 
-  @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, it will raise.
-
-  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
-    :application.set_env(config, opts)
-  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
-    maybe_warn_on_app_env_key(app, key)
+  @spec delete_env(app, key, [timeout: timeout, persistent: boolean]) :: :ok
+  def delete_env(app, key, opts \\ []) do
     :application.unset_env(app, key, opts)
   end
 
-  defp maybe_warn_on_app_env_key(_app, key) when is_atom(key),
-    do: :ok
-
-  # TODO: Remove this deprecation warning on 2.0+ and allow list lookups as in compile_env.
-  defp maybe_warn_on_app_env_key(app, key) do
-    message = "passing non-atom as application env key is deprecated, got: #{inspect(key)}"
-    IO.warn_once({Application, :key, app, key}, message, _stacktrace_drop_levels = 2)
-  end
-
   @doc """
   Ensures the given `app` is started.
 
@@ -816,27 +326,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/1` 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.
 
@@ -844,7 +338,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
@@ -883,7 +377,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
@@ -894,7 +388,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
 
@@ -945,50 +439,31 @@ defmodule Application do
       #=> "bar-123"
 
   For more information on code paths, check the `Code` module in
-  Elixir and also Erlang's [`:code` module](`:code`).
+  Elixir and also Erlang's [`:code` module](http://www.erlang.org/doc/man/code.html).
   """
-  @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
@@ -996,9 +471,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 """
@@ -1006,7 +481,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)
@@ -1025,8 +500,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.
@@ -1036,7 +511,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,9 +16,9 @@ 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)
+    :erlang.atom_to_binary(atom, :utf8)
   end
 
   @doc """
@@ -75,8 +37,9 @@ defmodule Atom do
     :erlang.atom_to_list(atom)
   end
 
+  # TODO: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
   @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,23 +1,18 @@
 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.
   """
-  @deprecated "Use the @callback module attribute instead"
   defmacro defcallback(spec) do
     do_defcallback(:def, split_spec(spec, quote(do: term)))
   end
@@ -25,12 +20,11 @@ defmodule Behaviour do
   @doc """
   Defines a macro callback according to the given type specification.
   """
-  @deprecated "Use the @macrocallback module attribute instead"
   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
 
@@ -38,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
 
@@ -50,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
@@ -76,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
 
@@ -92,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
@@ -103,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(%{"en" => doc}), do: doc
-      defp __behaviour__doc_value(:hidden), do: false
-      defp __behaviour__doc_value(_), do: nil
-
       import unquote(__MODULE__)
     end
   end

lib/elixir/lib/bitwise.ex

@@ -1,40 +1,50 @@
 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 `band/2`,
-  `bor/2`, `bsl/2`, and `bsr/2` also have operators,
-  respectively: `&&&/2`, `|||/2`, `<<</2`, and `>>>/2`.
+  The macros in this module come in two flavors: named or
+  operators. For example:
 
-  ## Guards
+      iex> use Bitwise
+      iex> bnot 1   # named
+      -2
+      iex> 1 &&& 1  # operator
+      1
 
-  All bitwise functions can be used in guards:
+  If you prefer to use only operators or skip them, you can
+  pass the following options:
 
-      iex> odd? = fn
-      ...>   int when Bitwise.band(int, 1) == 1 -> true
-      ...>   _ -> false
-      ...> end
+    * `:only_operators` - includes only operators
+    * `:skip_operators` - skips operators
+
+  For example:
+
+      iex> use Bitwise, only_operators: true
+      iex> 1 &&& 1
+      1
+
+  When invoked with no options, `use Bitwise` is equivalent
+  to `import Bitwise`.
+
+  All bitwise macros can be used in guards:
+
+      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
-  @deprecated "import Bitwise instead"
   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)
@@ -42,229 +52,162 @@ defmodule Bitwise do
   end
 
   @doc """
-  Calculates the bitwise NOT of the argument.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
+  Calculates the bitwise NOT of its argument.
 
       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 false
-  def unquote(:"~~~")(expr) do
-    :erlang.bnot(expr)
+  @doc """
+  Prefix (unary) operator; calculates the bitwise NOT of its argument.
+
+      iex> ~~~2
+      -3
+      iex> ~~~2 &&& 3
+      1
+
+  """
+  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 """
-  Bitwise AND operator.
-
-  Calculates the bitwise AND of its arguments.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
+  Infix operator; calculates the bitwise AND of its arguments.
 
       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 """
-  Bitwise OR operator.
-
-  Calculates the bitwise OR of its arguments.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
+  Infix operator; calculates the bitwise OR of its arguments.
 
       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 false
-  def unquote(:"^^^")(left, right) do
-    :erlang.bxor(left, right)
+  @doc """
+  Infix operator; calculates the bitwise XOR of its arguments.
+
+      iex> 9 ^^^ 3
+      10
+
+  """
+  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 """
-  Arithmetic left bitshift operator.
-
-  Calculates the result of an arithmetic left bitshift.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
+  Infix operator; calculates the result of an arithmetic left bitshift.
 
       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 """
-  Arithmetic right bitshift operator.
-
-  Calculates the result of an arithmetic right bitshift.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
+  Infix operator; calculates the result of an arithmetic right bitshift.
 
       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.ex

@@ -11,26 +11,17 @@ defmodule Calendar do
   For the actual date, time and datetime structures, see `Date`,
   `Time`, `NaiveDateTime` and `DateTime`.
 
-  Note designations for year, month, day, and the like, are overspecified
+  Note the year, month, day, etc. designations are overspecified
   (i.e. an integer instead of `1..12` for months) because different
   calendars may have a different number of days per month, months per year and so on.
   """
 
   @type year :: integer
-  @type month :: pos_integer
-  @type day :: pos_integer
-  @type week :: pos_integer
-  @type day_of_week :: non_neg_integer
-  @type era :: non_neg_integer
-
-  @typedoc """
-  A tuple representing the `day` and the `era`.
-  """
-  @type day_of_era :: {day :: non_neg_integer(), era}
-
-  @type hour :: non_neg_integer
-  @type minute :: non_neg_integer
-  @type second :: non_neg_integer
+  @type month :: integer
+  @type day :: integer
+  @type hour :: integer
+  @type minute :: integer
+  @type second :: integer
 
   @typedoc """
   The internal time format is used when converting between calendars.
@@ -44,9 +35,14 @@ defmodule Calendar do
   @typedoc """
   The internal date format that is used when converting between calendars.
 
-  This is the number of days including the fractional part that has passed of
-  the last day since 0000-01-01+00:00T00:00.000000 in ISO 8601 notation (also
-  known as midnight 1 January BC 1 of the proleptic Gregorian calendar).
+  This is the amount of days including the fractional part that has passed of
+  the last day since 0000-01-01+00:00T00:00.00000 in ISO 8601 notation (also
+  known as midnight 1 January BC 1 of the Proleptic Gregorian Calendar).
+
+  The `parts_per_day` represent how many subparts the current day is subdivided in
+  (for different calendars, picking a different `parts_per_day` might make sense).
+  The `parts_in_day` represents how many of these `parts_per_day` have passed in the
+  last day.
   """
   @type iso_days :: {days :: integer, day_fraction}
 
@@ -57,94 +53,37 @@ defmodule Calendar do
   representing the microseconds to external format. If the precision is 0,
   it means microseconds must be skipped.
   """
-  @type microsecond :: {value :: non_neg_integer, precision :: non_neg_integer}
+  @type microsecond :: {0..999_999, 0..6}
 
   @typedoc "A calendar implementation"
   @type calendar :: module
 
-  @typedoc "The time zone ID according to the IANA tz database (for example, Europe/Zurich)"
-  @type time_zone :: String.t()
+  @typedoc "The time zone ID according to the IANA tz database (e.g. Europe/Zurich)"
+  @type time_zone :: String.t
 
-  @typedoc "The time zone abbreviation (for example, CET or CEST or BST, and such)"
-  @type zone_abbr :: String.t()
+  @typedoc "The time zone abbreviation (e.g. CET or CEST or BST etc.)"
+  @type zone_abbr :: String.t
 
-  @typedoc """
-  The time zone UTC offset in seconds for standard time.
-
-  See also `t:std_offset/0`.
-  """
+  @typedoc "The time zone UTC offset in seconds"
   @type utc_offset :: integer
 
-  @typedoc """
-  The time zone standard offset in seconds (typically not zero in summer times).
-
-  It must be added to `t:utc_offset/0` to get the total offset from UTC used for "wall time".
-  """
+  @typedoc "The time zone standard offset in seconds (not zero in summer times)"
   @type std_offset :: integer
 
   @typedoc "Any map/struct that contains the date fields"
   @type date :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day}
 
   @typedoc "Any map/struct that contains the time fields"
-  @type time :: %{
-          optional(any) => any,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        }
+  @type time :: %{optional(any) => any, hour: hour, minute: minute, second: second, microsecond: microsecond}
 
   @typedoc "Any map/struct that contains the naive_datetime fields"
-  @type naive_datetime :: %{
-          optional(any) => any,
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        }
+  @type naive_datetime :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day,
+                            hour: hour, minute: minute, second: second, microsecond: microsecond}
 
   @typedoc "Any map/struct that contains the datetime fields"
-  @type datetime :: %{
-          optional(any) => any,
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond,
-          time_zone: time_zone,
-          zone_abbr: zone_abbr,
-          utc_offset: utc_offset,
-          std_offset: std_offset
-        }
-
-  @typedoc """
-  Specifies the time zone database for calendar operations.
-
-  Many functions in the `DateTime` module require a time zone database.
-  By default, it uses the default time zone database returned by
-  `Calendar.get_time_zone_database/0`, which defaults to
-  `Calendar.UTCOnlyTimeZoneDatabase` which only handles "Etc/UTC"
-  datetimes and returns `{:error, :utc_only_time_zone_database}`
-  for any other time zone.
-
-  Other time zone databases (including ones provided by packages)
-  can be configured as default either via configuration:
-
-      config :elixir, :time_zone_database, CustomTimeZoneDatabase
-
-  or by calling `Calendar.put_time_zone_database/1`.
-
-  See `Calendar.TimeZoneDatabase` for more information on custom
-  time zone databases.
-  """
-  @type time_zone_database :: module()
+  @type datetime :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day,
+                      hour: hour, minute: minute, second: second, microsecond: microsecond,
+                      time_zone: time_zone, zone_abbr: zone_abbr, utc_offset: utc_offset, std_offset: std_offset}
 
   @doc """
   Returns how many days there are in the given year-month.
@@ -152,12 +91,7 @@ defmodule Calendar do
   @callback days_in_month(year, month) :: day
 
   @doc """
-  Returns how many months there are in the given year.
-  """
-  @callback months_in_year(year) :: month
-
-  @doc """
-  Returns `true` if the given year is a leap year.
+  Returns true if the given year is a leap year.
 
   A leap year is a year of a longer length than normal. The exact meaning
   is up to the calendar. A calendar must return `false` if it does not support
@@ -167,87 +101,47 @@ defmodule Calendar do
 
   @doc """
   Calculates the day of the week from the given `year`, `month`, and `day`.
-
-  The `starting_on` represents the starting day of the week. All
-  calendars must support at least the `:default` value. They may
-  also support other values representing their days of the week.
   """
-  @callback day_of_week(year, month, day, starting_on :: :default | atom) ::
-              {day_of_week(), first_day_of_week :: non_neg_integer(),
-               last_day_of_week :: non_neg_integer()}
-
-  @doc """
-  Calculates the day of the year from the given `year`, `month`, and `day`.
-  """
-  @callback day_of_year(year, month, day) :: non_neg_integer()
-
-  @doc """
-  Calculates the quarter of the year from the given `year`, `month`, and `day`.
-  """
-  @callback quarter_of_year(year, month, day) :: non_neg_integer()
-
-  @doc """
-  Calculates the year and era from the given `year`.
-  """
-  @callback year_of_era(year, month, day) :: {year, era}
-
-  @doc """
-  Calculates the day and era from the given `year`, `month`, and `day`.
-  """
-  @callback day_of_era(year, month, day) :: day_of_era()
+  @callback day_of_week(year, month, day) :: non_neg_integer()
 
   @doc """
   Converts the date into a string according to the calendar.
   """
-  @callback date_to_string(year, month, day) :: String.t()
+  @callback date_to_string(year, month, day) :: String.t
 
   @doc """
   Converts the datetime (without time zone) into a string according to the calendar.
   """
-  @callback naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) ::
-              String.t()
+  @callback naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) :: String.t
 
   @doc """
   Converts the datetime (with time zone) into a string according to the calendar.
   """
-  @callback datetime_to_string(
-              year,
-              month,
-              day,
-              hour,
-              minute,
-              second,
-              microsecond,
-              time_zone,
-              zone_abbr,
-              utc_offset,
-              std_offset
-            ) :: String.t()
+  @callback datetime_to_string(year, month, day, hour, minute, second, microsecond,
+                               time_zone, zone_abbr, utc_offset, std_offset) :: String.t
 
   @doc """
   Converts the time into a string according to the calendar.
   """
-  @callback time_to_string(hour, minute, second, microsecond) :: String.t()
+  @callback time_to_string(hour, minute, second, microsecond) :: String.t
 
   @doc """
-  Converts the given datetime (without time zone) into the `t:iso_days/0` format.
+  Converts the given datetime (with time zone) into the `t:iso_days` format.
   """
-  @callback naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) ::
-              iso_days
+  @callback naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) :: iso_days
 
   @doc """
-  Converts `t:iso_days/0` to the Calendar's datetime format.
+  Converts `t:iso_days` to the Calendar's datetime format.
   """
-  @callback naive_datetime_from_iso_days(iso_days) ::
-              {year, month, day, hour, minute, second, microsecond}
+  @callback naive_datetime_from_iso_days(iso_days) :: {year, month, day, hour, minute, second, microsecond}
 
   @doc """
-  Converts the given time to the `t:day_fraction/0` format.
+  Converts the given time to the `t:day_fraction` format.
   """
   @callback time_to_day_fraction(hour, minute, second, microsecond) :: day_fraction
 
   @doc """
-  Converts `t:day_fraction/0` to the Calendar's time format.
+  Converts `t:day_fraction` to the Calendar's time format.
   """
   @callback time_from_day_fraction(day_fraction) :: {hour, minute, second, microsecond}
 
@@ -284,47 +178,6 @@ defmodule Calendar do
   """
   @callback valid_time?(hour, minute, second, microsecond) :: boolean
 
-  @doc """
-  Parses the string representation for a time returned by `c:time_to_string/4`
-  into a time-tuple.
-  """
-  @doc since: "1.10.0"
-  @callback parse_time(String.t()) ::
-              {:ok, {hour, minute, second, microsecond}}
-              | {:error, atom}
-
-  @doc """
-  Parses the string representation for a date returned by `c:date_to_string/3`
-  into a date-tuple.
-  """
-  @doc since: "1.10.0"
-  @callback parse_date(String.t()) ::
-              {:ok, {year, month, day}}
-              | {:error, atom}
-
-  @doc """
-  Parses the string representation for a naive datetime returned by
-  `c:naive_datetime_to_string/7` into a naive-datetime-tuple.
-
-  The given string may contain a timezone offset but it is ignored.
-  """
-  @doc since: "1.10.0"
-  @callback parse_naive_datetime(String.t()) ::
-              {:ok, {year, month, day, hour, minute, second, microsecond}}
-              | {:error, atom}
-
-  @doc """
-  Parses the string representation for a datetime returned by
-  `c:datetime_to_string/11` into a datetime-tuple.
-
-  The returned datetime must be in UTC. The original `utc_offset`
-  it was written in must be returned in the result.
-  """
-  @doc since: "1.10.0"
-  @callback parse_utc_datetime(String.t()) ::
-              {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}
-              | {:error, atom}
-
   # General Helpers
 
   @doc """
@@ -335,559 +188,9 @@ defmodule Calendar do
   between them. If they are compatible, this means that we can also convert
   dates as well as naive datetimes between them.
   """
-  @doc since: "1.5.0"
-  @spec compatible_calendars?(Calendar.calendar(), Calendar.calendar()) :: boolean
+  @spec compatible_calendars?(Calendar.calendar, Calendar.calendar) :: boolean
   def compatible_calendars?(calendar, calendar), do: true
-
   def compatible_calendars?(calendar1, calendar2) do
-    calendar1.day_rollover_relative_to_midnight_utc() ==
-      calendar2.day_rollover_relative_to_midnight_utc()
-  end
-
-  @doc """
-  Returns a microsecond tuple truncated to a given precision (`:microsecond`,
-  `:millisecond` or `:second`).
-  """
-  @doc since: "1.6.0"
-  @spec truncate(Calendar.microsecond(), :microsecond | :millisecond | :second) ::
-          Calendar.microsecond()
-  def truncate(microsecond_tuple, :microsecond), do: microsecond_tuple
-
-  def truncate({microsecond, precision}, :millisecond) do
-    output_precision = min(precision, 3)
-    {div(microsecond, 1000) * 1000, output_precision}
-  end
-
-  def truncate(_, :second), do: {0, 0}
-
-  @doc """
-  Sets the current time zone database.
-  """
-  @doc since: "1.8.0"
-  @spec put_time_zone_database(time_zone_database()) :: :ok
-  def put_time_zone_database(database) when is_atom(database) do
-    Application.put_env(:elixir, :time_zone_database, database)
-  end
-
-  @doc """
-  Gets the current time zone database.
-  """
-  @doc since: "1.8.0"
-  @spec get_time_zone_database() :: time_zone_database()
-  def get_time_zone_database() do
-    Application.fetch_env!(:elixir, :time_zone_database)
-  end
-
-  @doc """
-  Formats received datetime into a string.
-
-  The datetime can be any of the Calendar types (`Time`, `Date`,
-  `NaiveDateTime`, and `DateTime`) or any map, as long as they
-  contain all of the relevant fields necessary for formatting.
-  For example, if you use `%Y` to format the year, the datetime
-  must have the `:year` field. Therefore, if you pass a `Time`,
-  or a map without the `:year` field to a format that expects `%Y`,
-  an error will be raised.
-
-  ## Options
-
-    * `:preferred_datetime` - a string for the preferred format to show datetimes,
-      it can't contain the `%c` format and defaults to `"%Y-%m-%d %H:%M:%S"`
-      if the option is not received
-
-    * `:preferred_date` - a string for the preferred format to show dates,
-      it can't contain the `%x` format and defaults to `"%Y-%m-%d"`
-      if the option is not received
-
-    * `:preferred_time` - a string for the preferred format to show times,
-      it can't contain the `%X` format and defaults to `"%H:%M:%S"`
-      if the option is not received
-
-    * `:am_pm_names` - a function that receives either `:am` or `:pm` and returns
-      the name of the period of the day, if the option is not received it defaults
-      to a function that returns `"am"` and `"pm"`, respectively
-
-    *  `:month_names` - a function that receives a number and returns the name of
-      the corresponding month, if the option is not received it defaults to a
-      function that returns the month names in English
-
-    * `:abbreviated_month_names` - a function that receives a number and returns the
-      abbreviated name of the corresponding month, if the option is not received it
-      defaults to a function that returns the abbreviated month names in English
-
-    * `:day_of_week_names` - a function that receives a number and returns the name of
-      the corresponding day of week, if the option is not received it defaults to a
-      function that returns the day of week names in English
-
-    * `:abbreviated_day_of_week_names` - a function that receives a number and returns
-      the abbreviated name of the corresponding day of week, if the option is not received
-      it defaults to a function that returns the abbreviated day of week names in English
-
-  ## Formatting syntax
-
-  The formatting syntax for strftime is a sequence of characters in the following format:
-
-      %<padding><width><format>
-
-  where:
-
-    * `%`: indicates the start of a formatted section
-    * `<padding>`: set the padding (see below)
-    * `<width>`: a number indicating the minimum size of the formatted section
-    * `<format>`: the format itself (see below)
-
-  ### Accepted padding options
-
-    * `-`: no padding, removes all padding from the format
-    * `_`: pad with spaces
-    * `0`: pad with zeroes
-
-  ### Accepted formats
-
-  The accepted formats are:
-
-  Format | Description                                                             | Examples (in ISO)
-  :----- | :-----------------------------------------------------------------------| :------------------------
-  a      | Abbreviated name of day                                                 | Mon
-  A      | Full name of day                                                        | Monday
-  b      | Abbreviated month name                                                  | Jan
-  B      | Full month name                                                         | January
-  c      | Preferred date+time representation                                      | 2018-10-17 12:34:56
-  d      | Day of the month                                                        | 01, 31
-  f      | Microseconds *(does not support width and padding modifiers)*           | 000000, 999999, 0123
-  H      | Hour using a 24-hour clock                                              | 00, 23
-  I      | Hour using a 12-hour clock                                              | 01, 12
-  j      | Day of the year                                                         | 001, 366
-  m      | Month                                                                   | 01, 12
-  M      | Minute                                                                  | 00, 59
-  p      | "AM" or "PM" (noon is "PM", midnight as "AM")                           | AM, PM
-  P      | "am" or "pm" (noon is "pm", midnight as "am")                           | am, pm
-  q      | Quarter                                                                 | 1, 2, 3, 4
-  S      | Second                                                                  | 00, 59, 60
-  u      | Day of the week                                                         | 1 (Monday), 7 (Sunday)
-  x      | Preferred date (without time) representation                            | 2018-10-17
-  X      | Preferred time (without date) representation                            | 12:34:56
-  y      | Year as 2-digits                                                        | 01, 01, 86, 18
-  Y      | Year                                                                    | -0001, 0001, 1986
-  z      | +hhmm/-hhmm time zone offset from UTC (empty string if naive)           | +0300, -0530
-  Z      | Time zone abbreviation (empty string if naive)                          | CET, BRST
-  %      | Literal "%" character                                                   | %
-
-  Any other character will be interpreted as an invalid format and raise an error
-
-  ## Examples
-
-  Without options:
-
-      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%y-%m-%d %I:%M:%S %p")
-      "19-08-26 01:52:06 PM"
-
-      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%a, %B %d %Y")
-      "Mon, August 26 2019"
-
-      iex> Calendar.strftime(~U[2020-04-02 13:52:06.0Z], "%B %-d, %Y")
-      "April 2, 2020"
-
-      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%c")
-      "2019-08-26 13:52:06"
-
-  With options:
-
-      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%c", preferred_datetime: "%H:%M:%S %d-%m-%y")
-      "13:52:06 26-08-19"
-
-      iex> Calendar.strftime(
-      ...>  ~U[2019-08-26 13:52:06.0Z],
-      ...>  "%A",
-      ...>  day_of_week_names: fn day_of_week ->
-      ...>    {"segunda-feira", "terça-feira", "quarta-feira", "quinta-feira",
-      ...>    "sexta-feira", "sábado", "domingo"}
-      ...>    |> elem(day_of_week - 1)
-      ...>  end
-      ...>)
-      "segunda-feira"
-
-      iex> Calendar.strftime(
-      ...>  ~U[2019-08-26 13:52:06.0Z],
-      ...>  "%B",
-      ...>  month_names: fn month ->
-      ...>    {"январь", "февраль", "март", "апрель", "май", "июнь",
-      ...>    "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"}
-      ...>    |> elem(month - 1)
-      ...>  end
-      ...>)
-      "август"
-  """
-  @doc since: "1.11.0"
-  @spec strftime(map(), String.t(), keyword()) :: String.t()
-  def strftime(date_or_time_or_datetime, string_format, user_options \\ [])
-      when is_map(date_or_time_or_datetime) and is_binary(string_format) do
-    parse(
-      string_format,
-      date_or_time_or_datetime,
-      options(user_options),
-      []
-    )
-    |> IO.iodata_to_binary()
-  end
-
-  defp parse("", _datetime, _format_options, acc),
-    do: Enum.reverse(acc)
-
-  defp parse("%" <> rest, datetime, format_options, acc),
-    do: parse_modifiers(rest, nil, nil, {datetime, format_options, acc})
-
-  defp parse(<<char, rest::binary>>, datetime, format_options, acc),
-    do: parse(rest, datetime, format_options, [char | acc])
-
-  defp parse_modifiers("-" <> rest, width, nil, parser_data) do
-    parse_modifiers(rest, width, "", parser_data)
-  end
-
-  defp parse_modifiers("0" <> rest, nil, nil, parser_data) do
-    parse_modifiers(rest, nil, ?0, parser_data)
-  end
-
-  defp parse_modifiers("_" <> rest, width, nil, parser_data) do
-    parse_modifiers(rest, width, ?\s, parser_data)
-  end
-
-  defp parse_modifiers(<<digit, rest::binary>>, width, pad, parser_data) when digit in ?0..?9 do
-    new_width = (width || 0) * 10 + (digit - ?0)
-
-    parse_modifiers(rest, new_width, pad, parser_data)
-  end
-
-  # set default padding if none was specified
-  defp parse_modifiers(<<format, _::binary>> = rest, width, nil, parser_data) do
-    parse_modifiers(rest, width, default_pad(format), parser_data)
-  end
-
-  # set default width if none was specified
-  defp parse_modifiers(<<format, _::binary>> = rest, nil, pad, parser_data) do
-    parse_modifiers(rest, default_width(format), pad, parser_data)
-  end
-
-  defp parse_modifiers(rest, width, pad, {datetime, format_options, acc}) do
-    format_modifiers(rest, width, pad, datetime, format_options, acc)
-  end
-
-  defp am_pm(hour, format_options) when hour > 11 do
-    format_options.am_pm_names.(:pm)
-  end
-
-  defp am_pm(hour, format_options) when hour <= 11 do
-    format_options.am_pm_names.(:am)
-  end
-
-  defp default_pad(format) when format in 'aAbBpPZ', do: ?\s
-  defp default_pad(_format), do: ?0
-
-  defp default_width(format) when format in 'dHImMSy', do: 2
-  defp default_width(?j), do: 3
-  defp default_width(format) when format in 'Yz', do: 4
-  defp default_width(_format), do: 0
-
-  # Literally just %
-  defp format_modifiers("%" <> rest, width, pad, datetime, format_options, acc) do
-    parse(rest, datetime, format_options, [pad_leading("%", width, pad) | acc])
-  end
-
-  # Abbreviated name of day
-  defp format_modifiers("a" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      datetime
-      |> Date.day_of_week()
-      |> format_options.abbreviated_day_of_week_names.()
-      |> pad_leading(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Full name of day
-  defp format_modifiers("A" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      datetime
-      |> Date.day_of_week()
-      |> format_options.day_of_week_names.()
-      |> pad_leading(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Abbreviated month name
-  defp format_modifiers("b" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      datetime.month
-      |> format_options.abbreviated_month_names.()
-      |> pad_leading(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Full month name
-  defp format_modifiers("B" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.month |> format_options.month_names.() |> pad_leading(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Preferred date+time representation
-  defp format_modifiers(
-         "c" <> _rest,
-         _width,
-         _pad,
-         _datetime,
-         %{preferred_datetime_invoked: true},
-         _acc
-       ) do
-    raise ArgumentError,
-          "tried to format preferred_datetime within another preferred_datetime format"
-  end
-
-  defp format_modifiers("c" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      format_options.preferred_datetime
-      |> parse(datetime, %{format_options | preferred_datetime_invoked: true}, [])
-      |> pad_preferred(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Day of the month
-  defp format_modifiers("d" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.day |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Microseconds
-  defp format_modifiers("f" <> rest, _width, _pad, datetime, format_options, acc) do
-    {microsecond, precision} = datetime.microsecond
-
-    result =
-      microsecond
-      |> Integer.to_string()
-      |> String.pad_leading(6, "0")
-      |> binary_part(0, max(precision, 1))
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Hour using a 24-hour clock
-  defp format_modifiers("H" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.hour |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Hour using a 12-hour clock
-  defp format_modifiers("I" <> rest, width, pad, datetime, format_options, acc) do
-    result = (rem(datetime.hour() + 23, 12) + 1) |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Day of the year
-  defp format_modifiers("j" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime |> Date.day_of_year() |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Month
-  defp format_modifiers("m" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.month |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Minute
-  defp format_modifiers("M" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.minute |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # "AM" or "PM" (noon is "PM", midnight as "AM")
-  defp format_modifiers("p" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.hour |> am_pm(format_options) |> String.upcase() |> pad_leading(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # "am" or "pm" (noon is "pm", midnight as "am")
-  defp format_modifiers("P" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      datetime.hour
-      |> am_pm(format_options)
-      |> String.downcase()
-      |> pad_leading(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Quarter
-  defp format_modifiers("q" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime |> Date.quarter_of_year() |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Second
-  defp format_modifiers("S" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.second |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Day of the week
-  defp format_modifiers("u" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime |> Date.day_of_week() |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Preferred date (without time) representation
-  defp format_modifiers(
-         "x" <> _rest,
-         _width,
-         _pad,
-         _datetime,
-         %{preferred_date_invoked: true},
-         _acc
-       ) do
-    raise ArgumentError,
-          "tried to format preferred_date within another preferred_date format"
-  end
-
-  defp format_modifiers("x" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      format_options.preferred_date
-      |> parse(datetime, %{format_options | preferred_date_invoked: true}, [])
-      |> pad_preferred(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Preferred time (without date) representation
-  defp format_modifiers(
-         "X" <> _rest,
-         _width,
-         _pad,
-         _datetime,
-         %{preferred_time_invoked: true},
-         _acc
-       ) do
-    raise ArgumentError,
-          "tried to format preferred_time within another preferred_time format"
-  end
-
-  defp format_modifiers("X" <> rest, width, pad, datetime, format_options, acc) do
-    result =
-      format_options.preferred_time
-      |> parse(datetime, %{format_options | preferred_time_invoked: true}, [])
-      |> pad_preferred(width, pad)
-
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Year as 2-digits
-  defp format_modifiers("y" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime.year |> rem(100) |> Integer.to_string() |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # Year
-  defp format_modifiers("Y" <> rest, width, pad, datetime, format_options, acc) do
-    {sign, year} =
-      if datetime.year < 0 do
-        {?-, -datetime.year}
-      else
-        {[], datetime.year}
-      end
-
-    result = [sign | year |> Integer.to_string() |> pad_leading(width, pad)]
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  # +hhmm/-hhmm time zone offset from UTC (empty string if naive)
-  defp format_modifiers(
-         "z" <> rest,
-         width,
-         pad,
-         datetime = %{utc_offset: utc_offset, std_offset: std_offset},
-         format_options,
-         acc
-       ) do
-    absolute_offset = abs(utc_offset + std_offset)
-
-    offset_number =
-      Integer.to_string(div(absolute_offset, 3600) * 100 + rem(div(absolute_offset, 60), 60))
-
-    sign = if utc_offset + std_offset >= 0, do: "+", else: "-"
-    result = "#{sign}#{pad_leading(offset_number, width, pad)}"
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  defp format_modifiers("z" <> rest, _width, _pad, datetime, format_options, acc) do
-    parse(rest, datetime, format_options, ["" | acc])
-  end
-
-  # Time zone abbreviation (empty string if naive)
-  defp format_modifiers("Z" <> rest, width, pad, datetime, format_options, acc) do
-    result = datetime |> Map.get(:zone_abbr, "") |> pad_leading(width, pad)
-    parse(rest, datetime, format_options, [result | acc])
-  end
-
-  defp format_modifiers(rest, _width, _pad, _datetime, _format_options, _acc) do
-    {next, _rest} = String.next_grapheme(rest) || {"", ""}
-    raise ArgumentError, "invalid strftime format: %#{next}"
-  end
-
-  defp pad_preferred(result, width, pad) when length(result) < width do
-    pad_preferred([pad | result], width, pad)
-  end
-
-  defp pad_preferred(result, _width, _pad), do: result
-
-  defp pad_leading(string, count, padding) do
-    to_pad = count - byte_size(string)
-    if to_pad > 0, do: do_pad_leading(to_pad, padding, string), else: string
-  end
-
-  defp do_pad_leading(0, _, acc), do: acc
-
-  defp do_pad_leading(count, padding, acc),
-    do: do_pad_leading(count - 1, padding, [padding | acc])
-
-  defp options(user_options) do
-    default_options = %{
-      preferred_date: "%Y-%m-%d",
-      preferred_time: "%H:%M:%S",
-      preferred_datetime: "%Y-%m-%d %H:%M:%S",
-      am_pm_names: fn
-        :am -> "am"
-        :pm -> "pm"
-      end,
-      month_names: fn month ->
-        {"January", "February", "March", "April", "May", "June", "July", "August", "September",
-         "October", "November", "December"}
-        |> elem(month - 1)
-      end,
-      day_of_week_names: fn day_of_week ->
-        {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
-        |> elem(day_of_week - 1)
-      end,
-      abbreviated_month_names: fn month ->
-        {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}
-        |> elem(month - 1)
-      end,
-      abbreviated_day_of_week_names: fn day_of_week ->
-        {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"} |> elem(day_of_week - 1)
-      end,
-      preferred_datetime_invoked: false,
-      preferred_date_invoked: false,
-      preferred_time_invoked: false
-    }
-
-    Enum.reduce(user_options, default_options, fn {key, value}, acc ->
-      if Map.has_key?(acc, key) do
-        %{acc | key => value}
-      else
-        raise ArgumentError, "unknown option #{inspect(key)} given to Calendar.strftime/3"
-      end
-    end)
+    calendar1.day_rollover_relative_to_midnight_utc() == calendar2.day_rollover_relative_to_midnight_utc()
   end
 end

lib/elixir/lib/calendar/date.ex

@@ -3,8 +3,8 @@ defmodule Date do
   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 `sigil_D/2`) sigil:
+  New dates can be built with the `new/3` function or using the `~D`
+  sigil:
 
       iex> ~D[2000-01-01]
       ~D[2000-01-01]
@@ -25,24 +25,19 @@ defmodule Date do
 
   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.
+  as the ones in 3rd party calendar libraries.
 
   ## Comparing dates
 
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
+  Comparisons in Elixir using `==`, `>`, `<` and similar are structural
   and based on the `Date` struct fields. For proper comparison between
-  dates, use the `compare/2` function. The existence of the `compare/2`
-  function in this module also allows using `Enum.min/2` and `Enum.max/2`
-  functions to get the minimum and maximum date of an `Enum`. For example:
-
-      iex>  Enum.min([~D[2017-03-31], ~D[2017-04-01]], Date)
-      ~D[2017-03-31]
+  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
+  or retrieving the amount of days betweens instants. For example, if there
+  is an interest in computing the amount of days from the Unix epoch
   (1970-01-01):
 
       iex> Date.diff(~D[2010-04-17], ~D[1970-01-01])
@@ -58,12 +53,8 @@ defmodule Date do
   @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()
-        }
+  @type t :: %Date{year: Calendar.year, month: Calendar.month,
+                   day: Calendar.day, calendar: Calendar.calendar}
 
   @doc """
   Returns a range of dates.
@@ -77,83 +68,42 @@ defmodule Date do
   ## Examples
 
       iex> Date.range(~D[1999-01-01], ~D[2000-01-01])
-      Date.range(~D[1999-01-01], ~D[2000-01-01])
+      #DateRange<~D[1999-01-01], ~D[2000-01-01]>
+
+      iex> Date.range(~N[2000-01-01 09:00:00], ~D[1999-01-01])
+      #DateRange<~N[2000-01-01 09:00:00], ~D[1999-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> range
-      Date.range(~D[2001-01-01], ~D[2002-01-01])
       iex> Enum.count(range)
       366
-      iex> ~D[2001-02-01] in range
+      iex> Enum.member?(range, ~D[2001-02-01])
       true
-      iex> Enum.take(range, 3)
-      [~D[2001-01-01], ~D[2001-01-02], ~D[2001-01-03]]
-
+      iex> Enum.reduce(range, 0, fn _date, acc -> acc - 1 end)
+      -366
   """
-  @doc since: "1.5.0"
-  @spec range(Calendar.date(), Calendar.date()) :: Date.Range.t()
+
+  @spec range(Calendar.date, Calendar.date) :: Date.Range.t
   def range(%{calendar: calendar} = first, %{calendar: calendar} = last) do
     {first_days, _} = to_iso_days(first)
     {last_days, _} = to_iso_days(last)
-    # TODO: Deprecate inferring a range with a step of -1 on Elixir v1.16
-    step = if first_days <= last_days, do: 1, else: -1
-    range(first, first_days, last, last_days, calendar, step)
-  end
 
-  def range(%{calendar: _, year: _, month: _, day: _}, %{calendar: _, year: _, month: _, day: _}) do
-    raise ArgumentError, "both dates must have matching calendars"
-  end
-
-  @doc """
-  Returns a range of dates with a step.
-
-  ## Examples
-
-      iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01], 2)
-      iex> range
-      Date.range(~D[2001-01-01], ~D[2002-01-01], 2)
-      iex> Enum.count(range)
-      183
-      iex> ~D[2001-01-03] in range
-      true
-      iex> Enum.take(range, 3)
-      [~D[2001-01-01], ~D[2001-01-03], ~D[2001-01-05]]
-
-  """
-  @doc since: "1.12.0"
-  @spec range(Calendar.date(), Calendar.date(), step :: pos_integer | neg_integer) ::
-          Date.Range.t()
-  def range(%{calendar: calendar} = first, %{calendar: calendar} = last, step)
-      when is_integer(step) and step != 0 do
-    {first_days, _} = to_iso_days(first)
-    {last_days, _} = to_iso_days(last)
-    range(first, first_days, last, last_days, calendar, step)
-  end
-
-  def range(
-        %{calendar: _, year: _, month: _, day: _} = first,
-        %{calendar: _, year: _, month: _, day: _} = last,
-        step
-      ) do
-    raise ArgumentError,
-          "both dates must have matching calendar and the step must be a " <>
-            "non-zero integer, got: #{inspect(first)}, #{inspect(last)}, #{step}"
-  end
-
-  defp range(first, first_days, last, last_days, calendar, step) do
     %Date.Range{
-      first: %Date{calendar: calendar, year: first.year, month: first.month, day: first.day},
-      last: %Date{calendar: calendar, year: last.year, month: last.month, day: last.day},
+      first: first,
+      last: last,
       first_in_iso_days: first_days,
       last_in_iso_days: last_days,
-      step: step
     }
   end
 
+  def range(%{calendar: _, year: _, month: _, day: _},
+            %{calendar: _, year: _, month: _, day: _}) do
+    raise ArgumentError, "both dates must have matching calendars"
+  end
+
   @doc """
   Returns the current date in UTC.
 
@@ -164,23 +114,22 @@ defmodule Date do
       true
 
   """
-  @doc since: "1.4.0"
-  @spec utc_today(Calendar.calendar()) :: t
+  @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)
+    {: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()
+    |> DateTime.utc_now
+    |> DateTime.to_date
   end
 
   @doc """
-  Returns `true` if the year in the given `date` is a leap year.
+  Returns true if the year in the given `date` is a leap year.
 
   ## Examples
 
@@ -196,8 +145,7 @@ defmodule Date do
       true
 
   """
-  @doc since: "1.4.0"
-  @spec leap_year?(Calendar.date()) :: boolean()
+  @spec leap_year?(Calendar.date) :: boolean()
   def leap_year?(date)
 
   def leap_year?(%{calendar: calendar, year: year}) do
@@ -217,31 +165,13 @@ defmodule Date do
       29
 
   """
-  @doc since: "1.4.0"
-  @spec days_in_month(Calendar.date()) :: Calendar.day()
+  @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.
 
@@ -263,8 +193,7 @@ defmodule Date do
       {:error, :invalid_date}
 
   """
-  @spec new(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
+  @spec new(Calendar.year, Calendar.month, Calendar.day) :: {: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}}
@@ -273,33 +202,6 @@ defmodule Date do
     end
   end
 
-  @doc """
-  Builds a new ISO date.
-
-  Expects all values to be integers. Returns `date` if each
-  entry fits its appropriate range, raises if the date is invalid.
-
-  ## Examples
-
-      iex> Date.new!(2000, 1, 1)
-      ~D[2000-01-01]
-      iex> Date.new!(2000, 13, 1)
-      ** (ArgumentError) cannot build date, reason: :invalid_date
-      iex> Date.new!(2000, 2, 29)
-      ~D[2000-02-29]
-  """
-  @doc since: "1.11.0"
-  @spec new!(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) :: t
-  def new!(year, month, day, calendar \\ Calendar.ISO) do
-    case new(year, month, day, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError, "cannot build date, reason: #{inspect(reason)}"
-    end
-  end
-
   @doc """
   Converts the given date to a string according to its calendar.
 
@@ -309,11 +211,9 @@ defmodule Date do
       "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()
+  @spec to_string(Calendar.date) :: String.t
   def to_string(date)
 
   def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
@@ -321,10 +221,14 @@ defmodule Date do
   end
 
   @doc """
-  Parses the extended "Dates" format described by
-  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+  Parses the extended "Date and time of day" format described by
+  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
 
-  The year parsed by this function is limited to four digits.
+  Timezone offset may be included in the string but they will be
+  simply discarded as such information is not included in naive date
+  times.
+
+  Time representations with reduced accuracy are not supported.
 
   ## Examples
 
@@ -338,16 +242,27 @@ defmodule Date do
       {: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)
+  @spec from_iso8601(String.t) :: {:ok, t} | {:error, atom}
+  def from_iso8601(string, calendar \\ Calendar.ISO)
+
+  def from_iso8601(<<year::4-bytes, ?-, month::2-bytes, ?-, day::2-bytes>>, calendar) do
+    with {year, ""} <- Integer.parse(year),
+         {month, ""} <- Integer.parse(month),
+         {day, ""} <- Integer.parse(day) do
+      with {:ok, date} <- new(year, month, day, Calendar.ISO),
+           do: convert(date, calendar)
+    else
+      _ -> {:error, :invalid_format}
     end
   end
 
+  def from_iso8601(<<_::binary>>, _calendar) do
+    {:error, :invalid_format}
+  end
+
   @doc """
-  Parses the extended "Dates" format described by
-  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+  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.
 
@@ -357,22 +272,20 @@ defmodule Date do
       ~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
+  @spec from_iso8601!(String.t) :: 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)}"
+        raise ArgumentError, "cannot parse #{inspect string} as date, reason: #{inspect reason}"
     end
   end
 
   @doc """
   Converts the given `date` to
-  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+  [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.
@@ -393,18 +306,10 @@ defmodule Date do
       "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()
+  @spec to_iso8601(Calendar.date, :extended | :basic) :: String.t
+  def to_iso8601(date, format \\ :extended) when format in [:basic, :extended] do
+    %{year: year, month: month, day: day} = convert!(date, Calendar.ISO)
+    Calendar.ISO.date_to_iso8601(year, month, day, format)
   end
 
   @doc """
@@ -423,7 +328,7 @@ defmodule Date do
       {2000, 1, 1}
 
   """
-  @spec to_erl(Calendar.date()) :: :calendar.date()
+  @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}
@@ -444,11 +349,12 @@ defmodule Date do
       {:error, :invalid_date}
 
   """
-  @spec from_erl(:calendar.date(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
+  @spec from_erl(:calendar.date) :: {: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)
+    with {:ok, date} <- new(year, month, day, Calendar.ISO),
+         do: convert(date, calendar)
   end
 
   @doc """
@@ -462,57 +368,16 @@ defmodule Date do
       ** (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
+  @spec from_erl!(:calendar.date) :: t
+  def from_erl!(tuple) do
+    case from_erl(tuple) do
       {:ok, value} ->
         value
-
       {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to date, reason: #{inspect(reason)}"
+        raise ArgumentError, "cannot convert #{inspect tuple} to date, reason: #{inspect reason}"
     end
   end
 
-  @doc """
-  Converts a number of gregorian days to a `Date` struct.
-
-  ## Examples
-
-      iex> Date.from_gregorian_days(1)
-      ~D[0000-01-02]
-      iex> Date.from_gregorian_days(730_485)
-      ~D[2000-01-01]
-      iex> Date.from_gregorian_days(-1)
-      ~D[-0001-12-31]
-
-  """
-  @doc since: "1.11.0"
-  @spec from_gregorian_days(integer(), Calendar.calendar()) :: t
-  def from_gregorian_days(days, calendar \\ Calendar.ISO) when is_integer(days) do
-    from_iso_days({days, 0}, calendar)
-  end
-
-  @doc """
-  Converts a `date` struct to a number of gregorian days.
-
-  ## Examples
-
-      iex> Date.to_gregorian_days(~D[0000-01-02])
-      1
-      iex> Date.to_gregorian_days(~D[2000-01-01])
-      730_485
-      iex> Date.to_gregorian_days(~N[2000-01-01 00:00:00])
-      730_485
-
-  """
-  @doc since: "1.11.0"
-  @spec to_gregorian_days(Calendar.date()) :: integer()
-  def to_gregorian_days(date) do
-    {days, _} = to_iso_days(date)
-    days
-  end
-
   @doc """
   Compares two date structs.
 
@@ -536,21 +401,17 @@ defmodule Date do
       :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
-
+  @spec compare(Calendar.date, Calendar.date) :: :lt | :eq | :gt
+  def compare(%{calendar: calendar, year: year1, month: month1, day: day1},
+              %{calendar: calendar, year: year2, month: month2, day: day2}) do
     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(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do
-    if Calendar.compatible_calendars?(calendar1, calendar2) do
+  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
@@ -558,16 +419,16 @@ defmodule Date do
       end
     else
       raise ArgumentError, """
-      cannot compare #{inspect(date1)} with #{inspect(date2)}.
+      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
+      Specify an exact time of day (using `DateTime`s) to resolve this ambiguity
       """
     end
   end
 
   @doc """
-  Converts the given `date` from its calendar to the given `calendar`.
+  Converts the given `date` from it's calendar to the given `calendar`.
 
   Returns `{:ok, date}` if the calendars are compatible,
   or `{:error, :incompatible_calendars}` if they are not.
@@ -584,20 +445,16 @@ defmodule Date do
       {: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}
+  @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}
@@ -618,24 +475,20 @@ defmodule Date do
       %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}
 
   """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.date(), Calendar.calendar()) :: t
+  @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)}"
+        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
+  The days are counted as gregorian days. The date is returned in the same
   calendar as it was given in.
 
   ## Examples
@@ -644,34 +497,21 @@ defmodule Date do
       ~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
-
+  @spec add(Calendar.date, integer()) :: t
   def add(%{calendar: calendar} = date, days) do
-    {base_days, fraction} = to_iso_days(date)
-    from_iso_days({base_days + days, fraction}, calendar)
+    {iso_days_days, fraction} = to_iso_days(date)
+    from_iso_days({iso_days_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`
+  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.
 
@@ -681,20 +521,16 @@ defmodule Date do
       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)
+  @spec diff(Calendar.date, Calendar.date) :: integer
+  def diff(%{calendar: Calendar.ISO, year: year1, month: month1, day: day1},
+           %{calendar: Calendar.ISO, year: year2, month: month2, day: day2}) do
+    Calendar.ISO.date_to_iso_days_days(year1, month1, day1) -
+      Calendar.ISO.date_to_iso_days_days(year2, month2, day2)
   end
 
   def diff(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do
@@ -703,25 +539,21 @@ defmodule Date do
       {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"
+      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
 
-  @doc false
-  def 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}}
+  defp to_iso_days(%{calendar: Calendar.ISO, year: year, month: month, day: day}) do
+    {Calendar.ISO.date_to_iso_days_days(year, month, day), {0, 86400000000}}
   end
-
-  def to_iso_days(%{calendar: calendar, year: year, month: month, day: day}) do
+  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)
+    {year, month, day} = Calendar.ISO.date_from_iso_days_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}
@@ -734,11 +566,6 @@ defmodule Date do
   calendar (the default), it is an integer from 1 to 7, where
   1 is Monday and 7 is Sunday.
 
-  An optional `starting_on` value may be supplied, which
-  configures the weekday the week starts on. The default value
-  for it is `:default`, which translates to `:monday` for the
-  built-in ISO calendar. Any other weekday may be given to.
-
   ## Examples
 
       iex> Date.day_of_week(~D[2016-10-31])
@@ -747,282 +574,13 @@ defmodule Date do
       2
       iex> Date.day_of_week(~N[2016-11-01 01:23:45])
       2
-      iex> Date.day_of_week(~D[-0015-10-30])
-      3
-
-      iex> Date.day_of_week(~D[2016-10-31], :sunday)
-      2
-      iex> Date.day_of_week(~D[2016-11-01], :sunday)
-      3
-      iex> Date.day_of_week(~N[2016-11-01 01:23:45], :sunday)
-      3
-      iex> Date.day_of_week(~D[-0015-10-30], :sunday)
-      4
 
   """
-  @doc since: "1.4.0"
-  @spec day_of_week(Calendar.date(), starting_on :: :default | atom) :: Calendar.day_of_week()
-  def day_of_week(date, starting_on \\ :default)
+  @spec day_of_week(Calendar.date) :: non_neg_integer()
+  def day_of_week(date)
 
-  def day_of_week(%{calendar: calendar, year: year, month: month, day: day}, starting_on) do
-    {day_of_week, _first, _last} = calendar.day_of_week(year, month, day, starting_on)
-    day_of_week
-  end
-
-  @doc """
-  Calculates a date that is the first day of the week for the given `date`.
-
-  If the day is already the first day of the week, it returns the
-  day itself. For the built-in ISO calendar, the week starts on Monday.
-  A weekday rather than `:default` can be given as `starting_on`.
-
-  ## Examples
-
-      iex> Date.beginning_of_week(~D[2020-07-11])
-      ~D[2020-07-06]
-      iex> Date.beginning_of_week(~D[2020-07-06])
-      ~D[2020-07-06]
-      iex> Date.beginning_of_week(~D[2020-07-11], :sunday)
-      ~D[2020-07-05]
-      iex> Date.beginning_of_week(~D[2020-07-11], :saturday)
-      ~D[2020-07-11]
-      iex> Date.beginning_of_week(~N[2020-07-11 01:23:45])
-      ~D[2020-07-06]
-
-  """
-  @doc since: "1.11.0"
-  @spec beginning_of_week(Calendar.date(), starting_on :: :default | atom) :: Date.t()
-  def beginning_of_week(date, starting_on \\ :default)
-
-  def beginning_of_week(%{calendar: Calendar.ISO} = date, starting_on) do
-    %{year: year, month: month, day: day} = date
-    iso_days = Calendar.ISO.date_to_iso_days(year, month, day)
-
-    {year, month, day} =
-      case Calendar.ISO.iso_days_to_day_of_week(iso_days, starting_on) do
-        1 ->
-          {year, month, day}
-
-        day_of_week ->
-          Calendar.ISO.date_from_iso_days(iso_days - day_of_week + 1)
-      end
-
-    %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
-  end
-
-  def beginning_of_week(%{calendar: calendar} = date, starting_on) do
-    %{year: year, month: month, day: day} = date
-
-    case calendar.day_of_week(year, month, day, starting_on) do
-      {day_of_week, day_of_week, _} ->
-        %Date{calendar: calendar, year: year, month: month, day: day}
-
-      {day_of_week, first_day_of_week, _} ->
-        add(date, -(day_of_week - first_day_of_week))
-    end
-  end
-
-  @doc """
-  Calculates a date that is the last day of the week for the given `date`.
-
-  If the day is already the last day of the week, it returns the
-  day itself. For the built-in ISO calendar, the week ends on Sunday.
-  A weekday rather than `:default` can be given as `starting_on`.
-
-  ## Examples
-
-      iex> Date.end_of_week(~D[2020-07-11])
-      ~D[2020-07-12]
-      iex> Date.end_of_week(~D[2020-07-05])
-      ~D[2020-07-05]
-      iex> Date.end_of_week(~D[2020-07-06], :sunday)
-      ~D[2020-07-11]
-      iex> Date.end_of_week(~D[2020-07-06], :saturday)
-      ~D[2020-07-10]
-      iex> Date.end_of_week(~N[2020-07-11 01:23:45])
-      ~D[2020-07-12]
-
-  """
-  @doc since: "1.11.0"
-  @spec end_of_week(Calendar.date(), starting_on :: :default | atom) :: Date.t()
-  def end_of_week(date, starting_on \\ :default)
-
-  def end_of_week(%{calendar: Calendar.ISO} = date, starting_on) do
-    %{year: year, month: month, day: day} = date
-    iso_days = Calendar.ISO.date_to_iso_days(year, month, day)
-
-    {year, month, day} =
-      case Calendar.ISO.iso_days_to_day_of_week(iso_days, starting_on) do
-        7 ->
-          {year, month, day}
-
-        day_of_week ->
-          Calendar.ISO.date_from_iso_days(iso_days + 7 - day_of_week)
-      end
-
-    %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
-  end
-
-  def end_of_week(%{calendar: calendar} = date, starting_on) do
-    %{year: year, month: month, day: day} = date
-
-    case calendar.day_of_week(year, month, day, starting_on) do
-      {day_of_week, _, day_of_week} ->
-        %Date{calendar: calendar, year: year, month: month, day: day}
-
-      {day_of_week, _, last_day_of_week} ->
-        add(date, last_day_of_week - day_of_week)
-    end
-  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, month: month, day: day}) do
-    # TODO: Remove me on 1.17
-    # The behaviour implementation already warns on missing callback.
-    if function_exported?(calendar, :year_of_era, 3) do
-      calendar.year_of_era(year, month, day)
-    else
-      calendar.year_of_era(year)
-    end
-  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
-
-  @doc """
-  Calculates a date that is the first day of the month for the given `date`.
-
-  ## Examples
-
-      iex> Date.beginning_of_month(~D[2000-01-31])
-      ~D[2000-01-01]
-      iex> Date.beginning_of_month(~D[2000-01-01])
-      ~D[2000-01-01]
-      iex> Date.beginning_of_month(~N[2000-01-31 01:23:45])
-      ~D[2000-01-01]
-
-  """
-  @doc since: "1.11.0"
-  @spec beginning_of_month(Calendar.date()) :: t()
-  def beginning_of_month(date)
-
-  def beginning_of_month(%{year: year, month: month, calendar: calendar}) do
-    %Date{year: year, month: month, day: 1, calendar: calendar}
-  end
-
-  @doc """
-  Calculates a date that is the last day of the month for the given `date`.
-
-  ## Examples
-
-      iex> Date.end_of_month(~D[2000-01-01])
-      ~D[2000-01-31]
-      iex> Date.end_of_month(~D[2000-01-31])
-      ~D[2000-01-31]
-      iex> Date.end_of_month(~N[2000-01-01 01:23:45])
-      ~D[2000-01-31]
-
-  """
-  @doc since: "1.11.0"
-  @spec end_of_month(Calendar.date()) :: t()
-  def end_of_month(date)
-
-  def end_of_month(%{year: year, month: month, calendar: calendar} = date) do
-    day = Date.days_in_month(date)
-    %Date{year: year, month: month, day: day, calendar: calendar}
+  def day_of_week(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.day_of_week(year, month, day)
   end
 
   ## Helpers
@@ -1034,11 +592,12 @@ defmodule Date do
   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) <> "]"
+    def inspect(%{calendar: Calendar.ISO, year: year, month: month, day: day}, _) do
+      "~D[" <> Calendar.ISO.date_to_string(year, month, day) <> "]"
     end
 
-    defp suffix(Calendar.ISO), do: ""
-    defp suffix(calendar), do: " " <> inspect(calendar)
+    def inspect(date, opts) do
+      Inspect.Any.inspect(date, opts)
+    end
   end
 end

lib/elixir/lib/calendar/date_range.ex

@@ -2,226 +2,85 @@ defmodule Date.Range do
   @moduledoc """
   Returns an inclusive range between dates.
 
-  Ranges must be created with the `Date.range/2` or `Date.range/3` function.
+  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
-    * `:step` - (since v1.12.0) the step
 
   The remaining fields are private and should not be accessed.
   """
 
-  @type t :: %__MODULE__{
-          first: Date.t(),
-          last: Date.t(),
-          first_in_iso_days: days(),
-          last_in_iso_days: days(),
-          step: pos_integer | neg_integer
-        }
+  @type t :: %__MODULE__{first: Date.t, last: Date.t,
+                         first_in_iso_days: Calendar.days,
+                         last_in_iso_days: Calendar.days}
 
-  @typep days() :: integer()
-
-  @enforce_keys [:first, :last, :first_in_iso_days, :last_in_iso_days, :step]
-  defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days, :step]
+  defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days]
 
   defimpl Enumerable do
-    def member?(
-          %Date.Range{
-            first: %{calendar: calendar},
-            first_in_iso_days: first_days,
-            last_in_iso_days: last_days,
-            step: step
-          } = range,
-          %Date{calendar: calendar} = date
-        ) do
-      {days, _} = Date.to_iso_days(date)
+    def member?(%{first: %{calendar: calendar, year: first_year, month: first_month, day: first_day},
+                  last: %{calendar: calendar, year: last_year, month: last_month, day: last_day},
+                  first_in_iso_days: first_in_iso_days, last_in_iso_days: last_in_iso_days},
+                %Date{calendar: calendar, year: year, month: month, day: day}) do
+      first = {first_year, first_month, first_day}
+      last = {last_year, last_month, last_day}
+      date = {year, month, day}
 
-      cond do
-        empty?(range) ->
-          {:ok, false}
-
-        first_days <= last_days ->
-          {:ok, first_days <= days and days <= last_days and rem(days - first_days, step) == 0}
-
-        true ->
-          {:ok, last_days <= days and days <= first_days and rem(days - first_days, step) == 0}
+      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?(%Date.Range{step: _}, _) do
+    def member?(_, _) do
       {:ok, false}
     end
 
-    # TODO: Remove me on v2.0
-    def member?(
-          %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
-            date_range,
-          date
-        ) do
-      step = if first_days <= last_days, do: 1, else: -1
-      member?(Map.put(date_range, :step, step), date)
+    def count(%Date.Range{first_in_iso_days: first_in_iso_days, last_in_iso_days: last_in_iso_days}) do
+      {:ok, abs(first_in_iso_days - last_in_iso_days) + 1}
     end
 
-    def count(range) do
-      {:ok, size(range)}
+    def reduce(%Date.Range{first_in_iso_days: first_in_iso_days, last_in_iso_days: last_in_iso_days,
+                           first: %{calendar: calendar}}, acc, fun) do
+      reduce(first_in_iso_days, last_in_iso_days, acc, fun, calendar, first_in_iso_days <= last_in_iso_days)
     end
 
-    def slice(
-          %Date.Range{
-            first_in_iso_days: first,
-            first: %{calendar: calendar},
-            step: step
-          } = range
-        ) do
-      {:ok, size(range), &slice(first + &1 * step, step + &3 - 1, &2, calendar)}
-    end
-
-    # TODO: Remove me on v2.0
-    def slice(
-          %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
-            date_range
-        ) do
-      step = if first_days <= last_days, do: 1, else: -1
-      slice(Map.put(date_range, :step, step))
-    end
-
-    defp slice(current, _step, 1, calendar) do
-      [date_from_iso_days(current, calendar)]
-    end
-
-    defp slice(current, step, remaining, calendar) do
-      [
-        date_from_iso_days(current, calendar)
-        | slice(current + step, step, remaining - 1, calendar)
-      ]
-    end
-
-    def reduce(
-          %Date.Range{
-            first_in_iso_days: first_days,
-            last_in_iso_days: last_days,
-            first: %{calendar: calendar},
-            step: step
-          },
-          acc,
-          fun
-        ) do
-      reduce(first_days, last_days, acc, fun, step, calendar)
-    end
-
-    # TODO: Remove me on v2.0
-    def reduce(
-          %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
-            date_range,
-          acc,
-          fun
-        ) do
-      step = if first_days <= last_days, do: 1, else: -1
-      reduce(Map.put(date_range, :step, step), acc, fun)
-    end
-
-    defp reduce(_first_days, _last_days, {:halt, acc}, _fun, _step, _calendar) do
+    defp reduce(_x, _y, {:halt, acc}, _fun, _calendar, _up?) do
       {:halted, acc}
     end
 
-    defp reduce(first_days, last_days, {:suspend, acc}, fun, step, calendar) do
-      {:suspended, acc, &reduce(first_days, last_days, &1, fun, step, calendar)}
+    defp reduce(x, y, {:suspend, acc}, fun, calendar, up?) do
+      {:suspended, acc, &reduce(x, y, &1, fun, calendar, up?)}
     end
 
-    defp reduce(first_days, last_days, {:cont, acc}, fun, step, calendar)
-         when step > 0 and first_days <= last_days
-         when step < 0 and first_days >= last_days do
-      reduce(
-        first_days + step,
-        last_days,
-        fun.(date_from_iso_days(first_days, calendar), acc),
-        fun,
-        step,
-        calendar
-      )
+    defp reduce(x, y, {:cont, acc}, fun, calendar, up? = true) when x <= y do
+      reduce(x + 1, y, fun.(date_from_iso_days_days(x, calendar), acc), fun, calendar, up?)
     end
 
-    defp reduce(_, _, {:cont, acc}, _fun, _step, _calendar) do
+    defp reduce(x, y, {:cont, acc}, fun, calendar, up? = false) when x >= y do
+      reduce(x - 1, y, fun.(date_from_iso_days_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)
+    defp date_from_iso_days_days(days, Calendar.ISO) do
+      {year, month, day} = Calendar.ISO.date_from_iso_days_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}})
-
+    defp date_from_iso_days_days(days, calendar) do
+      {year, month, day, _, _, _, _} = calendar.naive_datetime_from_iso_days({days, {0, 86400000000}})
       %Date{year: year, month: month, day: day, calendar: calendar}
     end
-
-    defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step})
-         when step > 0 and first_days > last_days,
-         do: 0
-
-    defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step})
-         when step < 0 and first_days < last_days,
-         do: 0
-
-    defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step}),
-      do: abs(div(last_days - first_days, step)) + 1
-
-    # TODO: Remove me on v2.0
-    defp size(
-           %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
-             date_range
-         ) do
-      step = if first_days <= last_days, do: 1, else: -1
-      size(Map.put(date_range, :step, step))
-    end
-
-    defp empty?(%Date.Range{
-           first_in_iso_days: first_days,
-           last_in_iso_days: last_days,
-           step: step
-         })
-         when step > 0 and first_days > last_days,
-         do: true
-
-    defp empty?(%Date.Range{
-           first_in_iso_days: first_days,
-           last_in_iso_days: last_days,
-           step: step
-         })
-         when step < 0 and first_days < last_days,
-         do: true
-
-    defp empty?(%Date.Range{step: _}), do: false
-
-    # TODO: Remove me on v2.0
-    defp empty?(
-           %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
-             date_range
-         ) do
-      step = if first_days <= last_days, do: 1, else: -1
-      empty?(Map.put(date_range, :step, step))
-    end
   end
 
   defimpl Inspect do
-    import Kernel, except: [inspect: 2]
-
-    def inspect(%Date.Range{first: first, last: last, step: 1}, _) do
-      "Date.range(" <> inspect(first) <> ", " <> inspect(last) <> ")"
-    end
-
-    def inspect(%Date.Range{first: first, last: last, step: step}, _) do
-      "Date.range(" <> inspect(first) <> ", " <> inspect(last) <> ", #{step})"
-    end
-
-    # TODO: Remove me on v2.0
-    def inspect(%{__struct__: Date.Range, first: first, last: last} = date_range, opts) do
-      step = if first <= last, do: 1, else: -1
-      inspect(Map.put(date_range, :step, step), opts)
+    def inspect(%Date.Range{first: first, last: last}, _) do
+      "#DateRange<" <> inspect(first) <> ", " <> inspect(last) <> ">"
     end
   end
 end

lib/elixir/lib/calendar/time.ex

@@ -3,8 +3,8 @@ defmodule Time do
   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 `sigil_T/2`) sigil:
+  New times can be built with the `new/4` function or using the `~T`
+  sigil:
 
       iex> ~T[23:00:07.001]
       ~T[23:00:07.001]
@@ -25,33 +25,20 @@ defmodule Time do
 
   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.
+  as the ones in 3rd party calendar libraries.
 
   ## Comparing times
 
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
+  Comparisons in Elixir using `==`, `>`, `<` and similar are structural
   and based on the `Time` struct fields. For proper comparison between
-  times, use the `compare/2` function. The existence of the `compare/2`
-  function in this module also allows using `Enum.min/2` and `Enum.max/2`
-  functions to get the minimum and maximum time of an `Enum`. For example:
-
-      iex> Enum.min([~T[23:00:07.001], ~T[10:00:07.001]], Time)
-      ~T[10:00:07.001]
+  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
-  @seconds_per_day 24 * 60 * 60
+  @type t :: %Time{hour: Calendar.hour, minute: Calendar.minute,
+                   second: Calendar.second, microsecond: Calendar.microsecond, calendar: Calendar.calendar}
 
   @doc """
   Returns the current time in UTC.
@@ -63,20 +50,10 @@ defmodule Time do
       true
 
   """
-  @doc since: "1.4.0"
-  @spec utc_now(Calendar.calendar()) :: t
+  @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
-    }
-
+    {:ok, _, {hour, minute, second}, microsecond} = Calendar.ISO.from_unix(:os.system_time, :native)
+    iso_time = %Time{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: Calendar.ISO}
     convert!(iso_time, calendar)
   end
 
@@ -86,10 +63,9 @@ defmodule Time do
   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.
+  Note a time may have 60 seconds in case of leap seconds. Microseconds
+  can also be given with a precision, which must be an integer between
+  0 and 6.
 
   ## Examples
 
@@ -97,12 +73,18 @@ defmodule Time do
       {:ok, ~T[00:00:00.000000]}
       iex> Time.new(23, 59, 59, 999_999)
       {:ok, ~T[23:59:59.999999]}
+      iex> Time.new(23, 59, 60, 999_999)
+      {:ok, ~T[23:59:60.999999]}
+
+      # Time with microseconds and their precision
+      iex> Time.new(23, 59, 60, {10_000, 2})
+      {:ok, ~T[23:59:60.01]}
 
       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)
+      iex> Time.new(23, 59, 61, 999_999)
       {:error, :invalid_time}
       iex> Time.new(23, 59, 59, 1_000_000)
       {:error, :invalid_time}
@@ -112,13 +94,8 @@ defmodule Time do
       {:error, :invalid_time}
 
   """
-  @spec new(
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond() | non_neg_integer,
-          Calendar.calendar()
-        ) :: {:ok, t} | {:error, atom}
+  @spec new(Calendar.hour, Calendar.minute, Calendar.second, Calendar.microsecond, 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
@@ -127,62 +104,15 @@ defmodule Time do
 
   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
+           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}
-
+        {:ok, %Time{hour: hour, minute: minute, second: second, microsecond: {microsecond, precision}, calendar: calendar}}
       false ->
         {:error, :invalid_time}
     end
   end
 
-  @doc """
-  Builds a new time.
-
-  Expects all values to be integers. Returns `time` if each
-  entry fits its appropriate range, raises if the time is invalid.
-
-  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)
-      ~T[00:00:00.000000]
-      iex> Time.new!(23, 59, 59, 999_999)
-      ~T[23:59:59.999999]
-      iex> Time.new!(24, 59, 59, 999_999)
-      ** (ArgumentError) cannot build time, reason: :invalid_time
-  """
-  @doc since: "1.11.0"
-  @spec new!(
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond() | non_neg_integer,
-          Calendar.calendar()
-        ) :: t
-  def new!(hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
-    case new(hour, minute, second, microsecond, calendar) do
-      {:ok, time} ->
-        time
-
-      {:error, reason} ->
-        raise ArgumentError, "cannot build time, reason: #{inspect(reason)}"
-    end
-  end
-
   @doc """
   Converts the given `time` to a string.
 
@@ -201,29 +131,28 @@ defmodule Time do
       "23:00:00.123456"
 
   """
-  @spec to_string(Calendar.time()) :: String.t()
+  @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
+  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:2019](https://en.wikipedia.org/wiki/ISO_8601).
+  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
 
-  Time zone offset may be included in the string but they will be
+  Timezone 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 ISO8601 allows times to specify 24:00:00 as the
+  zero hour of the next day, this notation is not supported by Elixir.
+
   ## Examples
 
       iex> Time.from_iso8601("23:50:07")
@@ -250,19 +179,33 @@ defmodule Time do
       {: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
-      )
+  @spec from_iso8601(String.t) :: {:ok, t} | {:error, atom}
+  def from_iso8601(string, calendar \\ Calendar.ISO)
+
+  def from_iso8601(<<?T, h, rest::binary>>, calendar) when h in ?0..?9 do
+    from_iso8601(<<h, rest::binary>>, calendar)
+  end
+
+  def from_iso8601(<<hour::2-bytes, ?:, min::2-bytes, ?:, sec::2-bytes, rest::binary>>, calendar) do
+    with {hour, ""} <- Integer.parse(hour),
+         {min, ""} <- Integer.parse(min),
+         {sec, ""} <- Integer.parse(sec),
+         {microsec, rest} <- Calendar.ISO.parse_microsecond(rest),
+         {_offset, ""} <- Calendar.ISO.parse_offset(rest) do
+      with {:ok, utc_time} <- new(hour, min, sec, microsec, Calendar.ISO),
+           do: convert(utc_time, calendar)
+    else
+      _ -> {:error, :invalid_format}
     end
   end
 
+  def from_iso8601(<<_::binary>>, _calendar) do
+    {:error, :invalid_format}
+  end
+
   @doc """
   Parses the extended "Local time" format described by
-  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
 
   Raises if the format is invalid.
 
@@ -274,22 +217,20 @@ defmodule Time do
       ~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
+  @spec from_iso8601!(String.t) :: t
+  def from_iso8601!(string) do
+    case from_iso8601(string) do
       {:ok, value} ->
         value
-
       {:error, reason} ->
-        raise ArgumentError, "cannot parse #{inspect(string)} as time, reason: #{inspect(reason)}"
+        raise ArgumentError, "cannot parse #{inspect string} as time, reason: #{inspect reason}"
     end
   end
 
   @doc """
   Converts the given time to
-  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+  [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
@@ -310,24 +251,10 @@ defmodule Time do
       "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)
+  @spec to_iso8601(Calendar.time, :extended | :basic) :: String.t
+  def to_iso8601(time, format \\ :extended) when format in [:extended, :basic] do
+    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = convert!(time, Calendar.ISO)
+    Calendar.ISO.time_to_iso8601(hour, minute, second, microsecond, format)
   end
 
   @doc """
@@ -345,7 +272,7 @@ defmodule Time do
       {23, 30, 15}
 
   """
-  @spec to_erl(Calendar.time()) :: :calendar.time()
+  @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}
@@ -362,8 +289,7 @@ defmodule Time do
       {:error, :invalid_time}
 
   """
-  @spec from_erl(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
+  @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
@@ -384,169 +310,16 @@ defmodule Time do
       ** (ArgumentError) cannot convert {24, 30, 15} to time, reason: :invalid_time
 
   """
-  @spec from_erl!(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) :: t
+  @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)}"
+        raise ArgumentError, "cannot convert #{inspect tuple} to time, reason: #{inspect reason}"
     end
   end
 
-  @doc """
-  Converts a number of seconds after midnight to a `Time` struct.
-
-  ## Examples
-
-      iex> Time.from_seconds_after_midnight(10_000)
-      ~T[02:46:40]
-      iex> Time.from_seconds_after_midnight(30_000, {5000, 3})
-      ~T[08:20:00.005]
-      iex> Time.from_seconds_after_midnight(-1)
-      ~T[23:59:59]
-      iex> Time.from_seconds_after_midnight(100_000)
-      ~T[03:46:40]
-
-  """
-  @doc since: "1.11.0"
-  @spec from_seconds_after_midnight(
-          integer(),
-          Calendar.microsecond(),
-          Calendar.calendar()
-        ) :: t
-  def from_seconds_after_midnight(seconds, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-      when is_integer(seconds) do
-    seconds_in_day = Integer.mod(seconds, @seconds_per_day)
-
-    {hour, minute, second, {_, _}} =
-      calendar.time_from_day_fraction({seconds_in_day, @seconds_per_day})
-
-    %Time{
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-  end
-
-  @doc """
-  Converts a `Time` struct to a number of seconds after midnight.
-
-  The returned value is a two-element tuple with the number of seconds and microseconds.
-
-  ## Examples
-
-      iex> Time.to_seconds_after_midnight(~T[23:30:15])
-      {84615, 0}
-      iex> Time.to_seconds_after_midnight(~N[2010-04-17 23:30:15.999])
-      {84615, 999000}
-
-  """
-  @doc since: "1.11.0"
-  @spec to_seconds_after_midnight(Calendar.time()) :: {integer(), non_neg_integer()}
-  def to_seconds_after_midnight(%{microsecond: {microsecond, _precision}} = time) do
-    iso_days = {0, to_day_fraction(time)}
-    {Calendar.ISO.iso_days_to_unit(iso_days, :second), microsecond}
-  end
-
-  @doc """
-  Adds the `amount_to_add` of `unit`s to the given `time`.
-
-  Accepts an `amount_to_add` in any `unit`. `unit` can be `:day`,
-  `:hour`, `:minute`, `:second` or any subsecond precision from
-  `t:System.time_unit/0`. It defaults to `:second`. Negative values
-  will move backwards in time.
-
-  This function always consider the unit to be computed according
-  to the `Calendar.ISO`.
-
-  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]
-      iex> Time.add(~T[11:00:00.005], 2400)
-      ~T[11:40:00.005]
-      iex> Time.add(~T[00:00:00.000], 86_399_999, :millisecond)
-      ~T[23:59:59.999]
-
-  Negative values are allowed:
-
-      iex> Time.add(~T[23:00:00], -60)
-      ~T[22:59:00]
-
-  Note that the time is cyclic:
-
-      iex> Time.add(~T[17:10:05], 86400)
-      ~T[17:10:05]
-
-  Hours and minutes are also supported:
-
-      iex> Time.add(~T[17:10:05], 2, :hour)
-      ~T[19:10:05]
-      iex> Time.add(~T[17:10:05], 30, :minute)
-      ~T[17:40:05]
-
-  This operation merges the precision of the time with the given unit:
-
-      iex> result = Time.add(~T[00:29:10], 21, :millisecond)
-      ~T[00:29:10.021]
-      iex> result.microsecond
-      {21000, 3}
-
-  """
-  @doc since: "1.6.0"
-  @spec add(Calendar.time(), integer, :hour | :minute | System.time_unit()) :: t
-  def add(time, amount_to_add, unit \\ :second)
-
-  def add(time, amount_to_add, :hour) when is_integer(amount_to_add) do
-    add(time, amount_to_add * 3600, :second)
-  end
-
-  def add(time, amount_to_add, :minute) when is_integer(amount_to_add) do
-    add(time, amount_to_add * 60, :second)
-  end
-
-  def add(%{calendar: calendar, microsecond: {_, precision}} = time, amount_to_add, unit)
-      when is_integer(amount_to_add) do
-    amount_to_add = System.convert_time_unit(amount_to_add, unit, :microsecond)
-    total = time_to_microseconds(time) + amount_to_add
-    parts = Integer.mod(total, @parts_per_day)
-    precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
-
-    {hour, minute, second, {microsecond, _}} =
-      calendar.time_from_day_fraction({parts, @parts_per_day})
-
-    %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: {microsecond, precision},
-      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.
 
@@ -574,12 +347,9 @@ defmodule Time do
       :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
-
+  @spec compare(Calendar.time, Calendar.time) :: :lt | :eq | :gt
+  def compare(%{calendar: calendar, hour: hour1, minute: minute1, second: second1, microsecond: {microsecond1, _}},
+              %{calendar: calendar, hour: hour2, minute: minute2, second: second2, microsecond: {microsecond2, _}}) do
     case {{hour1, minute1, second1, microsecond1}, {hour2, minute2, second2, microsecond2}} do
       {first, second} when first > second -> :gt
       {first, second} when first < second -> :lt
@@ -614,46 +384,18 @@ defmodule Time do
       {: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}
+  @spec convert(Calendar.time, Calendar.calendar) :: {:ok, t} | {:error, atom}
+  def convert(%{calendar: calendar, hour: hour, minute: minute, second: second, microsecond: microsecond}, calendar) do
+    {:ok, %Time{calendar: calendar, hour: hour, minute: minute, second: second, microsecond: microsecond}}
   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}
+      |> calendar.time_from_day_fraction
+    {:ok, %Time{calendar: calendar, hour: hour, minute: minute, second: second,
+                microsecond: {microsecond, precision}}}
   end
 
   @doc """
@@ -670,36 +412,32 @@ defmodule Time do
       %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
+  @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)}"
+        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,
+  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, minute, second, and microsecond is considered. Any
+  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 `:hour`, `:minute`, `:second` or any
-  subsecond `unit` available from `t:System.time_unit/0`. If the first time
-  value is earlier than the second, a negative number is returned.
+  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.
 
-  The unit is measured according to `Calendar.ISO` and defaults to `:second`.
-  Fractional results are not supported and are truncated.
+  This function returns the difference in seconds where seconds
+  are measured according to `Calendar.ISO`.
 
   ## Examples
 
@@ -712,7 +450,7 @@ defmodule Time do
 
       # 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])
+      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)
@@ -720,122 +458,34 @@ defmodule Time do
       iex> Time.diff(~T[00:29:10], ~T[00:29:12], :microsecond)
       -2_000_000
 
-      iex> Time.diff(~T[02:29:10], ~T[00:29:10], :hour)
-      2
-      iex> Time.diff(~T[02:29:10], ~T[00:29:11], :hour)
-      1
-
   """
-  @doc since: "1.5.0"
-  @spec diff(Calendar.time(), Calendar.time(), :hour | :minute | System.time_unit()) :: integer
-  def diff(time1, time2, unit \\ :second)
-
-  def diff(time1, time2, :hour) do
-    diff(time1, time2, :second) |> div(3600)
-  end
-
-  def diff(time1, time2, :minute) do
-    diff(time1, time2, :second) |> div(60)
-  end
-
-  def diff(
-        %{
-          calendar: Calendar.ISO,
-          hour: hour1,
-          minute: minute1,
-          second: second1,
-          microsecond: {microsecond1, _}
-        },
-        %{
-          calendar: Calendar.ISO,
-          hour: hour2,
-          minute: minute2,
-          second: second2,
-          microsecond: {microsecond2, _}
-        },
-        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
+  @spec diff(Calendar.time, Calendar.time, System.time_unit) :: integer
+  def diff(time1, time2, unit \\ :second) 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
+  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
-
+    def to_string(%{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: calendar}) do
       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) <> "]"
+    def inspect(%{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: Calendar.ISO}, _) do
+      "~T[" <> Calendar.ISO.time_to_string(hour, minute, second, microsecond) <> "]"
     end
 
-    defp suffix(Calendar.ISO), do: ""
-    defp suffix(calendar), do: " " <> inspect(calendar)
+    def inspect(time, opts) do
+      Inspect.Any.inspect(time, opts)
+    end
   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`, then a tuple with `:ok`
-  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,152 +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, 120}
-      op in [:&&, :&&&, :and] -> {:left, 130}
-      op in [:==, :!=, :=~, :===, :!==] -> {:left, 140}
-      op in [:<, :<=, :>=, :>] -> {:left, 150}
-      op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :"<|>"] -> {:left, 160}
-      op in [:in] -> {:left, 170}
-      op in [:"^^^"] -> {:left, 180}
-      op in [:"//"] -> {:right, 190}
-      op in [:++, :--, :.., :<>, :+++, :---] -> {:right, 200}
-      op in [:+, :-] -> {:left, 210}
-      op in [:*, :/] -> {:left, 220}
-      op in [:**] -> {:left, 230}
-      op in [:.] -> {:left, 310}
-      true -> :error
-    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.
-  """
-  @spec escape(binary(), char() | nil, :infinity | non_neg_integer, (char() -> iolist() | false)) ::
-          {escaped :: iolist(), remaining :: binary()}
-  def escape(binary, char, limit \\ :infinity, fun \\ &escape_map/1)
-      when ((char in 0..0x10FFFF or is_nil(char)) and limit == :infinity) or
-             (is_integer(limit) and limit >= 0) do
-    escape(binary, char, limit, [], 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/normalizer.ex

@@ -1,600 +0,0 @@
-defmodule Code.Normalizer do
-  @moduledoc false
-
-  defguard is_literal(x)
-           when is_integer(x) or
-                  is_float(x) or
-                  is_binary(x) or
-                  is_atom(x)
-
-  @doc """
-  Wraps literals in the quoted expression to conform to the AST format expected
-  by the formatter.
-  """
-  def normalize(quoted, opts \\ []) do
-    line = Keyword.get(opts, :line, nil)
-    escape = Keyword.get(opts, :escape, true)
-    locals_without_parens = Keyword.get(opts, :locals_without_parens, [])
-
-    state = %{
-      escape: escape,
-      parent_meta: [line: line],
-      locals_without_parens: locals_without_parens ++ Code.Formatter.locals_without_parens()
-    }
-
-    do_normalize(quoted, state)
-  end
-
-  # Wrapped literals should receive the block meta
-  defp do_normalize({:__block__, meta, [literal]}, state)
-       when not is_tuple(literal) or tuple_size(literal) == 2 do
-    normalize_literal(literal, meta, state)
-  end
-
-  # Only normalize the first argument of an alias if it's not an atom
-  defp do_normalize({:__aliases__, meta, [first | rest]}, state) when not is_atom(first) do
-    meta = patch_meta_line(meta, state.parent_meta)
-    first = do_normalize(first, %{state | parent_meta: meta})
-    {:__aliases__, meta, [first | rest]}
-  end
-
-  defp do_normalize({:__aliases__, _, _} = quoted, _state) do
-    quoted
-  end
-
-  # Skip captured arguments like &1
-  defp do_normalize({:&, meta, [term]}, state) when is_integer(term) do
-    meta = patch_meta_line(meta, state.parent_meta)
-    {:&, meta, [term]}
-  end
-
-  # Ranges
-  defp do_normalize(left..right//step, state) do
-    left = do_normalize(left, state)
-    right = do_normalize(right, state)
-    meta = meta_line(state)
-
-    if step == 1 do
-      {:.., meta, [left, right]}
-    else
-      step = do_normalize(step, state)
-      {:"..//", meta, [left, right, step]}
-    end
-  end
-
-  # Bit containers
-  defp do_normalize({:<<>>, _, args} = quoted, state) when is_list(args) do
-    normalize_bitstring(quoted, state)
-  end
-
-  # Atoms with interpolations
-  defp do_normalize(
-         {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta,
-          [{:<<>>, _, parts} = string, :utf8]},
-         state
-       )
-       when is_list(parts) do
-    dot_meta = patch_meta_line(dot_meta, state.parent_meta)
-    call_meta = patch_meta_line(call_meta, dot_meta)
-
-    utf8 =
-      if parts == [] or binary_interpolated?(parts) do
-        # a non-normalized :utf8 atom signals an atom interpolation
-        :utf8
-      else
-        normalize_literal(:utf8, [], state)
-      end
-
-    string =
-      if state.escape do
-        normalize_bitstring(string, state, true)
-      else
-        normalize_bitstring(string, state)
-      end
-
-    {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta, [string, utf8]}
-  end
-
-  # Charlists with interpolations
-  defp do_normalize({{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]} = quoted, state) do
-    if list_interpolated?(parts) do
-      parts =
-        Enum.map(parts, fn
-          {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args} ->
-            args = normalize_args(args, state)
-
-            {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args}
-
-          part when is_binary(part) ->
-            if state.escape do
-              maybe_escape_literal(part, state)
-            else
-              part
-            end
-        end)
-
-      {{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]}
-    else
-      normalize_call(quoted, state)
-    end
-  end
-
-  # Don't normalize the `Access` atom in access syntax
-  defp do_normalize({:., meta, [Access, :get]}, state) do
-    meta = patch_meta_line(meta, state.parent_meta)
-    {:., meta, [Access, :get]}
-  end
-
-  # Only normalize the left side of the dot operator
-  # The right hand side is an atom in the AST but it's not an atom literal, so
-  # it should not be wrapped
-  defp do_normalize({:., meta, [left, right]}, state) do
-    meta = patch_meta_line(meta, state.parent_meta)
-
-    left = do_normalize(left, %{state | parent_meta: meta})
-
-    {:., meta, [left, right]}
-  end
-
-  # A list of left to right arrows is not considered as a list literal, so it's not wrapped
-  defp do_normalize([{:->, _, [_ | _]} | _] = quoted, state) do
-    normalize_args(quoted, state)
-  end
-
-  # left -> right
-  defp do_normalize({:->, meta, [left, right]}, state) do
-    meta = patch_meta_line(meta, state.parent_meta)
-
-    left = normalize_args(left, %{state | parent_meta: meta})
-    right = do_normalize(right, %{state | parent_meta: meta})
-    {:->, meta, [left, right]}
-  end
-
-  # Maps
-  defp do_normalize({:%{}, meta, args}, state) when is_list(args) do
-    meta =
-      if meta == [] do
-        line = state.parent_meta[:line]
-        [line: line, closing: [line: line]]
-      else
-        meta
-      end
-
-    state = %{state | parent_meta: meta}
-
-    args =
-      case args do
-        [{:|, pipe_meta, [left, right]}] ->
-          left = do_normalize(left, state)
-          right = normalize_map_args(right, state)
-          [{:|, pipe_meta, [left, right]}]
-
-        [{_, _, _} = call] ->
-          [do_normalize(call, state)]
-
-        args ->
-          normalize_map_args(args, state)
-      end
-
-    {:%{}, meta, args}
-  end
-
-  # Sigils
-  defp do_normalize({sigil, meta, [{:<<>>, _, args} = string, modifiers]} = quoted, state)
-       when is_list(args) and is_atom(sigil) do
-    case Atom.to_string(sigil) do
-      <<"sigil_", _name>> ->
-        meta =
-          meta
-          |> patch_meta_line(state.parent_meta)
-          |> Keyword.put_new(:delimiter, "\"")
-
-        {sigil, meta, [do_normalize(string, %{state | parent_meta: meta}), modifiers]}
-
-      _ ->
-        normalize_call(quoted, state)
-    end
-  end
-
-  # Tuples
-  defp do_normalize({:{}, meta, args} = quoted, state) when is_list(args) do
-    {last_arg, args} = List.pop_at(args, -1)
-
-    if args != [] and match?([_ | _], last_arg) and keyword?(last_arg) do
-      args = normalize_args(args, state)
-      kw_list = normalize_kw_args(last_arg, state, true)
-      {:{}, meta, args ++ kw_list}
-    else
-      normalize_call(quoted, state)
-    end
-  end
-
-  # Module attributes
-  defp do_normalize({:@, meta, [{name, name_meta, [value]}]}, state) do
-    value =
-      cond do
-        keyword?(value) and value != [] ->
-          normalize_kw_args(value, state, true)
-
-        is_list(value) ->
-          normalize_literal(value, meta, state)
-
-        true ->
-          do_normalize(value, state)
-      end
-
-    {:@, meta, [{name, name_meta, [value]}]}
-  end
-
-  # Regular blocks
-  defp do_normalize({:__block__, meta, args}, state) when is_list(args) do
-    {:__block__, meta, normalize_args(args, state)}
-  end
-
-  # Calls
-  defp do_normalize({_, _, args} = quoted, state) when is_list(args) do
-    normalize_call(quoted, state)
-  end
-
-  # Vars
-  defp do_normalize({_, _, context} = quoted, _state) when is_atom(context) do
-    quoted
-  end
-
-  # Literals
-  defp do_normalize(quoted, state) do
-    normalize_literal(quoted, [], state)
-  end
-
-  # Numbers
-  defp normalize_literal(number, meta, state) when is_number(number) do
-    meta =
-      meta
-      |> Keyword.put_new(:token, inspect(number))
-      |> patch_meta_line(state.parent_meta)
-
-    {:__block__, meta, [number]}
-  end
-
-  # Atom, Strings
-  defp normalize_literal(literal, meta, state) when is_atom(literal) or is_binary(literal) do
-    meta = patch_meta_line(meta, state.parent_meta)
-    literal = maybe_escape_literal(literal, state)
-
-    if is_atom(literal) and Macro.classify_atom(literal) == :alias and
-         is_nil(meta[:delimiter]) do
-      segments =
-        case Atom.to_string(literal) do
-          "Elixir" ->
-            [:"Elixir"]
-
-          "Elixir." <> segments ->
-            segments
-            |> String.split(".")
-            |> Enum.map(&String.to_atom/1)
-        end
-
-      {:__aliases__, meta, segments}
-    else
-      {:__block__, meta, [literal]}
-    end
-  end
-
-  # 2-tuples
-  defp normalize_literal({left, right}, meta, state) do
-    meta = patch_meta_line(meta, state.parent_meta)
-    state = %{state | parent_meta: meta}
-
-    if match?([_ | _], right) and keyword?(right) do
-      {:__block__, meta, [{do_normalize(left, state), normalize_kw_args(right, state, true)}]}
-    else
-      {:__block__, meta, [{do_normalize(left, state), do_normalize(right, state)}]}
-    end
-  end
-
-  # Lists
-  defp normalize_literal(list, meta, state) when is_list(list) do
-    if list != [] and List.ascii_printable?(list) do
-      # It's a charlist
-      list =
-        if state.escape do
-          {string, _} = Code.Identifier.escape(IO.chardata_to_string(list), nil)
-          IO.iodata_to_binary(string) |> to_charlist()
-        else
-          list
-        end
-
-      meta =
-        meta
-        |> Keyword.put_new(:delimiter, "'")
-        |> patch_meta_line(state.parent_meta)
-
-      {:__block__, meta, [list]}
-    else
-      meta =
-        if line = state.parent_meta[:line] do
-          meta
-          |> Keyword.put_new(:closing, line: line)
-          |> patch_meta_line(state.parent_meta)
-        else
-          meta
-        end
-
-      {:__block__, meta, [normalize_kw_args(list, state, false)]}
-    end
-  end
-
-  # Probably an invalid value, wrap it and send it upstream
-  defp normalize_literal(quoted, meta, _state) do
-    {:__block__, meta, [quoted]}
-  end
-
-  defp normalize_call({form, meta, args}, state) do
-    meta = patch_meta_line(meta, state.parent_meta)
-    arity = length(args)
-
-    # Only normalize the form if it's a qualified call
-    form =
-      if is_atom(form) do
-        form
-      else
-        do_normalize(form, %{state | parent_meta: meta})
-      end
-
-    meta =
-      if is_nil(meta[:no_parens]) and is_nil(meta[:closing]) and is_nil(meta[:do]) and
-           not Code.Formatter.local_without_parens?(form, arity, state.locals_without_parens) do
-        [closing: [line: meta[:line]]] ++ meta
-      else
-        meta
-      end
-
-    cond do
-      Keyword.has_key?(meta, :do) or match?([{{:__block__, _, [:do]}, _} | _], List.last(args)) ->
-        # def foo do :ok end
-        # def foo, do: :ok
-        normalize_kw_blocks(form, meta, args, state)
-
-      match?([{:do, _} | _], List.last(args)) ->
-        # Non normalized kw blocks
-        line = state.parent_meta[:line]
-        meta = meta ++ [do: [line: line], end: [line: line]]
-        normalize_kw_blocks(form, meta, args, state)
-
-      allow_keyword?(form, arity) ->
-        args = normalize_args(args, %{state | parent_meta: meta})
-        {last_arg, leading_args} = List.pop_at(args, -1, [])
-
-        last_args =
-          case last_arg do
-            {:__block__, _, [[{{:__block__, key_meta, _}, _} | _]] = last_args} ->
-              if key_meta[:format] == :keyword do
-                last_args
-              else
-                [last_arg]
-              end
-
-            [] ->
-              []
-
-            _ ->
-              [last_arg]
-          end
-
-        {form, meta, leading_args ++ last_args}
-
-      true ->
-        args = normalize_args(args, %{state | parent_meta: meta})
-        {form, meta, args}
-    end
-  end
-
-  defp allow_keyword?(:when, 2), do: true
-  defp allow_keyword?(:{}, _), do: false
-  defp allow_keyword?(op, arity), do: not is_atom(op) or not Macro.operator?(op, arity)
-
-  defp normalize_bitstring({:<<>>, meta, parts}, state, escape_interpolation \\ false) do
-    meta = patch_meta_line(meta, state.parent_meta)
-
-    parts =
-      if binary_interpolated?(parts) do
-        normalize_interpolation_parts(parts, %{state | parent_meta: meta}, escape_interpolation)
-      else
-        state = %{state | parent_meta: meta}
-
-        Enum.map(parts, fn part ->
-          with {:"::", meta, [left, _]} <- part,
-               true <- meta[:inferred_bitstring_spec] do
-            do_normalize(left, state)
-          else
-            _ -> do_normalize(part, state)
-          end
-        end)
-      end
-
-    {:<<>>, meta, parts}
-  end
-
-  defp normalize_interpolation_parts(parts, state, escape_interpolation) do
-    Enum.map(parts, fn
-      {:"::", interpolation_meta,
-       [
-         {{:., dot_meta, [Kernel, :to_string]}, middle_meta, [middle]},
-         {:binary, binary_meta, context}
-       ]} ->
-        middle = do_normalize(middle, %{state | parent_meta: dot_meta})
-
-        {:"::", interpolation_meta,
-         [
-           {{:., dot_meta, [Kernel, :to_string]}, middle_meta, [middle]},
-           {:binary, binary_meta, context}
-         ]}
-
-      part ->
-        if escape_interpolation do
-          maybe_escape_literal(part, state)
-        else
-          part
-        end
-    end)
-  end
-
-  defp normalize_map_args(args, state) do
-    Enum.map(normalize_kw_args(args, state, false), fn
-      {:__block__, _, [{_, _} = pair]} -> pair
-      pair -> pair
-    end)
-  end
-
-  defp normalize_kw_blocks(form, meta, args, state) do
-    {kw_blocks, leading_args} = List.pop_at(args, -1)
-
-    kw_blocks =
-      Enum.map(kw_blocks, fn {tag, block} ->
-        block = do_normalize(block, %{state | parent_meta: meta})
-
-        block =
-          case block do
-            {_, _, [[{:->, _, _} | _] = block]} -> block
-            block -> block
-          end
-
-        # Only wrap the tag if it isn't already wrapped
-        tag =
-          case tag do
-            {:__block__, _, _} -> tag
-            _ -> {:__block__, [line: meta[:line]], [tag]}
-          end
-
-        {tag, block}
-      end)
-
-    leading_args = normalize_args(leading_args, %{state | parent_meta: meta})
-    {form, meta, leading_args ++ [kw_blocks]}
-  end
-
-  defp normalize_kw_args(elems, state, keyword?)
-
-  defp normalize_kw_args(
-         [{{:__block__, key_meta, [key]}, value} = first | rest] = current,
-         state,
-         keyword?
-       )
-       when is_atom(key) do
-    keyword? = keyword? or keyword?(current)
-
-    first =
-      if key_meta[:format] == :keyword and not keyword? do
-        key_meta = Keyword.delete(key_meta, :format)
-        line = key_meta[:line] || meta_line(state)
-        {:__block__, [line: line], [{{:__block__, key_meta, [key]}, value}]}
-      else
-        first
-      end
-
-    [first | normalize_kw_args(rest, state, keyword?)]
-  end
-
-  defp normalize_kw_args([{left, right} | rest] = current, state, keyword?) do
-    keyword? = keyword? or keyword?(current)
-
-    left =
-      if keyword? do
-        meta = [format: :keyword] ++ meta_line(state)
-        {:__block__, meta, [maybe_escape_literal(left, state)]}
-      else
-        do_normalize(left, state)
-      end
-
-    right = do_normalize(right, state)
-
-    pair =
-      with {:__block__, meta, _} <- left,
-           :keyword <- meta[:format] do
-        {left, right}
-      else
-        _ -> {:__block__, meta_line(state), [{left, right}]}
-      end
-
-    [pair | normalize_kw_args(rest, state, keyword?)]
-  end
-
-  defp normalize_kw_args([first | rest], state, keyword?) do
-    [do_normalize(first, state) | normalize_kw_args(rest, state, keyword?)]
-  end
-
-  defp normalize_kw_args([], _state, _keyword?) do
-    []
-  end
-
-  defp normalize_args(args, state) do
-    Enum.map(args, &do_normalize(&1, state))
-  end
-
-  defp maybe_escape_literal(string, %{escape: true}) when is_binary(string) do
-    {string, _} = Code.Identifier.escape(string, nil)
-    IO.iodata_to_binary(string)
-  end
-
-  defp maybe_escape_literal(atom, %{escape: true} = state) when is_atom(atom) do
-    atom
-    |> Atom.to_string()
-    |> maybe_escape_literal(state)
-    |> String.to_atom()
-  end
-
-  defp maybe_escape_literal(term, _) do
-    term
-  end
-
-  defp binary_interpolated?(parts) do
-    Enum.all?(parts, fn
-      {:"::", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true
-      binary when is_binary(binary) -> true
-      _ -> false
-    end)
-  end
-
-  defp list_interpolated?(parts) do
-    Enum.all?(parts, fn
-      {{:., _, [Kernel, :to_string]}, _, [_]} -> true
-      binary when is_binary(binary) -> true
-      _ -> false
-    end)
-  end
-
-  defp patch_meta_line(meta, parent_meta) do
-    with nil <- meta[:line],
-         line when is_integer(line) <- parent_meta[:line] do
-      [line: line] ++ meta
-    else
-      _ -> meta
-    end
-  end
-
-  defp meta_line(state) do
-    if line = state.parent_meta[:line] do
-      [line: line]
-    else
-      []
-    end
-  end
-
-  defp keyword?([{{:__block__, key_meta, [key]}, _} | rest]) when is_atom(key) do
-    if key_meta[:format] == :keyword do
-      keyword?(rest)
-    else
-      false
-    end
-  end
-
-  defp keyword?([{key, _value} | rest]) when is_atom(key) do
-    case Atom.to_charlist(key) do
-      'Elixir.' ++ _ -> false
-      _ -> keyword?(rest)
-    end
-  end
-
-  defp keyword?([]), do: true
-  defp keyword?(_other), do: false
-end

lib/elixir/lib/code/typespec.ex

@@ -1,423 +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, anno, :fun, [{:type, _, :product, args}, result]})
-      when is_atom(name) do
-    meta = meta(anno)
-    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, anno, :fun, []}) when is_atom(name) do
-    meta = meta(anno)
-    {:"::", meta, [{name, meta, []}, quote(do: term)]}
-  end
-
-  def spec_to_quoted(name, {:type, anno, :bounded_fun, [type, constrs]}) when is_atom(name) do
-    meta = meta(anno)
-    {: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
-
-    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, meta, 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
-    with {^module, beam, _filename} <- :code.get_object_code(module),
-         {:ok, ^module} <- beam |> :beam_lib.info() |> Keyword.fetch(:module) do
-      {module, beam}
-    else
-      _ -> :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, _anno, args}) when is_list(args) do
-    []
-  end
-
-  defp collect_vars({:type, _anno, _kind, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
-  end
-
-  defp collect_vars({:remote_type, _anno, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
-  end
-
-  defp collect_vars({:typed_record_field, _anno, type}) do
-    collect_vars(type)
-  end
-
-  defp collect_vars({:paren_type, _anno, [type]}) do
-    collect_vars(type)
-  end
-
-  defp collect_vars({:var, _anno, var}) do
-    [erl_to_ex_var(var)]
-  end
-
-  defp collect_vars(_) do
-    []
-  end
-
-  defp typespec_to_quoted({:user_type, anno, name, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {name, meta(anno), args}
-  end
-
-  defp typespec_to_quoted({:type, anno, :tuple, :any}) do
-    {:tuple, meta(anno), []}
-  end
-
-  defp typespec_to_quoted({:type, anno, :tuple, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {:{}, meta(anno), args}
-  end
-
-  defp typespec_to_quoted({:type, _anno, :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, anno, :list, []}) do
-    {:list, meta(anno), []}
-  end
-
-  defp typespec_to_quoted({:type, _anno, :list, [arg]}) do
-    [typespec_to_quoted(arg)]
-  end
-
-  defp typespec_to_quoted({:type, anno, :nonempty_list, []}) do
-    [{:..., meta(anno), nil}]
-  end
-
-  defp typespec_to_quoted({:type, anno, :nonempty_list, [arg]}) do
-    [typespec_to_quoted(arg), {:..., meta(anno), nil}]
-  end
-
-  defp typespec_to_quoted({:type, anno, :map, :any}) do
-    {:map, meta(anno), []}
-  end
-
-  defp typespec_to_quoted({:type, anno, :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)
-
-    case List.keytake(fields, :__struct__, 0) do
-      {{:__struct__, struct}, fields_pruned} when is_atom(struct) and struct != nil ->
-        map_pruned = {:%{}, meta(anno), fields_pruned}
-        {:%, meta(anno), [struct, map_pruned]}
-
-      _ ->
-        {:%{}, meta(anno), fields}
-    end
-  end
-
-  defp typespec_to_quoted({:type, anno, :binary, [arg1, arg2]}) do
-    [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_quoted(arg)
-    line = meta(anno)[:line]
-
-    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, anno, :union, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, meta(anno), [arg, expr]} end)
-  end
-
-  defp typespec_to_quoted({:type, anno, :fun, [{:type, _, :product, args}, result]}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    [{:->, meta(anno), [args, typespec_to_quoted(result)]}]
-  end
-
-  defp typespec_to_quoted({:type, anno, :fun, [args, result]}) do
-    [{:->, meta(anno), [[typespec_to_quoted(args)], typespec_to_quoted(result)]}]
-  end
-
-  defp typespec_to_quoted({:type, anno, :fun, []}) do
-    typespec_to_quoted({:type, anno, :fun, [{:type, anno, :any}, {:type, anno, :any, []}]})
-  end
-
-  defp typespec_to_quoted({:type, anno, :range, [left, right]}) do
-    {:.., meta(anno), [typespec_to_quoted(left), typespec_to_quoted(right)]}
-  end
-
-  defp typespec_to_quoted({:type, _anno, nil, []}) do
-    []
-  end
-
-  defp typespec_to_quoted({:type, anno, name, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {name, meta(anno), args}
-  end
-
-  defp typespec_to_quoted({:var, anno, var}) do
-    {erl_to_ex_var(var), meta(anno), nil}
-  end
-
-  defp typespec_to_quoted({:op, anno, op, arg}) do
-    {op, meta(anno), [typespec_to_quoted(arg)]}
-  end
-
-  defp typespec_to_quoted({:remote_type, anno, [mod, name, args]}) do
-    remote_type(anno, mod, name, args)
-  end
-
-  defp typespec_to_quoted({:ann_type, anno, [var, type]}) do
-    {:"::", meta(anno), [typespec_to_quoted(var), typespec_to_quoted(type)]}
-  end
-
-  defp typespec_to_quoted(
-         {:typed_record_field, {:record_field, anno1, {:atom, anno2, name}}, type}
-       ) do
-    typespec_to_quoted({:ann_type, anno1, [{:var, anno2, 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, _anno, atom}) when is_atom(type) do
-    atom
-  end
-
-  defp typespec_to_quoted(other), do: other
-
-  ## Helpers
-
-  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do
-    typespec_to_quoted({:type, anno, :charlist, []})
-  end
-
-  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do
-    typespec_to_quoted({:type, anno, :nonempty_charlist, []})
-  end
-
-  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :struct}, []) do
-    typespec_to_quoted({:type, anno, :struct, []})
-  end
-
-  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do
-    typespec_to_quoted({:type, anno, :as_boolean, [arg]})
-  end
-
-  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do
-    typespec_to_quoted({:type, anno, :keyword, args})
-  end
-
-  defp remote_type(anno, mod, name, args) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    dot = {:., meta(anno), [typespec_to_quoted(mod), typespec_to_quoted(name)]}
-    {dot, meta(anno), 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
-
-  defp meta(anno), do: [line: :erl_anno.line(anno)]
-end

lib/elixir/lib/collectable.ex

@@ -17,54 +17,42 @@ defprotocol Collectable do
 
   This design is intentional. `Enumerable` was designed to support infinite
   collections, resources and other structures with fixed shape. For example,
-  it doesn't make sense to insert values into a `Range`, as it has a
-  fixed shape where only the range limits and step are stored.
+  it doesn't make sense to insert values into a range, as it has a fixed
+  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.
+  `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.
 
   ## Examples
 
-  To show how to manually use the `Collectable` protocol, let's play with a
-  simplified implementation for `MapSet`.
+  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.new([1, 2, 3])
+      #MapSet<[1, 2, 3]>
 
-  To show how the protocol can be implemented, we can again look at the
-  simplified implementation for `MapSet`. In this implementation "collecting" elements
+  To show how the protocol can be implemented, we can take again a 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(map_set) do
+      defimpl Collectable do
+        def into(original) do
           collector_fun = fn
-            map_set_acc, {:cont, elem} ->
-              MapSet.put(map_set_acc, elem)
-
-            map_set_acc, :done ->
-              map_set_acc
-
-            _map_set_acc, :halt ->
-              :ok
+            set, {:cont, elem} -> MapSet.put(set, elem)
+            set, :done -> set
+            _set, :halt -> :ok
           end
 
-          initial_acc = map_set
-
-          {initial_acc, collector_fun}
+          {original, collector_fun}
         end
       end
 
-  So now we can call `Enum.into/2`:
-
-      iex> Enum.into([1, 2, 3], MapSet.new())
-      MapSet.new([1, 2, 3])
-
   """
 
   @type command :: {:cont, term} | :done | :halt
@@ -72,11 +60,8 @@ defprotocol Collectable do
   @doc """
   Returns an initial accumulator and a "collector" function.
 
-  Receives a `collectable` which can be used as the initial accumulator that will
-  be passed to the function.
-
-  The collector function receives a term and a command and injects the term into
-  the collectable accumulator on every `{:cont, term}` command.
+  The returned function receives a term and a command and injects the term into
+  the collectable on every `{:cont, term}` command.
 
   `: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
@@ -88,92 +73,36 @@ defprotocol Collectable do
   For examples on how to use the `Collectable` protocol and `into/1` see the
   module documentation.
   """
-  @spec into(t) :: {initial_acc :: term, collector :: (term, command -> t | term)}
+  @spec into(t) :: {term, (term, command -> t | term)}
   def into(collectable)
 end
 
 defimpl Collectable, for: List do
-  def into(list) do
-    # TODO: Change the behaviour so the into always comes last on Elixir v2.0
-    if list != [] do
-      IO.warn(
-        "the Collectable protocol is deprecated for non-empty lists. The behaviour of " <>
-          "Enum.into/2 and \"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
-      list_acc, {:cont, elem} ->
-        [elem | list_acc]
-
-      list_acc, :done ->
-        list ++ :lists.reverse(list_acc)
-
-      _list_acc, :halt ->
-        :ok
-    end
-
-    {[], fun}
+  def into(original) do
+    {[], fn
+      list, {:cont, x} -> [x | list]
+      list, :done -> original ++ :lists.reverse(list)
+      _, :halt -> :ok
+    end}
   end
 end
 
 defimpl Collectable, for: BitString do
-  def into(binary) when is_binary(binary) 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)
-
-      __acc, :halt ->
-        :ok
-    end
-
-    {[binary], fun}
-  end
-
-  def into(bitstring) do
-    fun = fn
-      acc, {:cont, x} when is_bitstring(x) ->
-        <<acc::bitstring, x::bitstring>>
-
-      acc, :done ->
-        acc
-
-      _acc, :halt ->
-        :ok
-    end
-
-    {bitstring, 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(map) do
-    fun = fn
-      map_acc, {:cont, {key, value}} ->
-        Map.put(map_acc, key, value)
-
-      map_acc, :done ->
-        map_acc
-
-      _map_acc, :halt ->
-        :ok
-    end
-
-    {map, fun}
+  def into(original) do
+    {original, fn
+      map, {:cont, {k, v}} -> :maps.put(k, v, map)
+      map, :done -> map
+      _, :halt -> :ok
+    end}
   end
 end

lib/elixir/lib/config.ex

@@ -1,359 +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 "#{config_env()}.exs"
-
-  `import Config` will import the functions `config/2`, `config/3`
-  `config_env/0`, `config_target/0`, 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 "#{config_env()}.exs"` will import
-  other config files based on the current configuration 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. Also note that
-  > the `config/config.exs` of a library is not evaluated when the library is
-  > used as a dependency, as configuration is always meant to configure the
-  > current project. For more information, read our [library guidelines](library-guidelines.md).
-
-  ## 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 three 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
-
-  The last step is to replace all `Mix.env()` calls in the config files with `config_env()`.
-
-  Keep in mind you must also avoid using `Mix.env()` inside your project files.
-  To check the environment at _runtime_, you may add a configuration key:
-
-      # config.exs
-      ...
-      config :my_app, env: config_env()
-
-  Then, in other scripts and modules, you may get the environment with
-  `Application.fetch_env!/2`:
-
-      # router.exs
-      ...
-      if Application.fetch_env!(:my_app, :env) == :prod do
-        ...
-      end
-
-  The only files where you may access functions from the `Mix` module are
-  the `mix.exs` file and inside custom Mix tasks, which always within the
-  `Mix.Tasks` namespace.
-
-  ## config/runtime.exs
-
-  For runtime configuration, you can use the `config/runtime.exs` file.
-  It is executed right before applications start in both Mix and releases
-  (assembled with `mix release`).
-  """
-
-  @opts_key {__MODULE__, :opts}
-  @config_key {__MODULE__, :config}
-  @imports_key {__MODULE__, :imports}
-
-  defp get_opts!(), do: Process.get(@opts_key) || raise_improper_use!()
-  defp put_opts(value), do: Process.put(@opts_key, value)
-  defp delete_opts(), do: Process.delete(@opts_key)
-
-  defp get_config!(), do: Process.get(@config_key) || raise_improper_use!()
-  defp put_config(value), do: Process.put(@config_key, value)
-  defp delete_config(), do: Process.delete(@config_key)
-
-  defp get_imports!(), do: Process.get(@imports_key) || raise_improper_use!()
-  defp put_imports(value), do: Process.put(@imports_key, value)
-  defp delete_imports(), do: Process.delete(@imports_key)
-
-  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`, unless they are keywords, which are
-  deep merged recursively. 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`, unless they are keywords, which are
-  deep merged recursively. For example, the application configuration
-  below
-
-      config :ecto, Repo,
-        log_level: :warn,
-        adapter: Ecto.Adapters.Postgres,
-        metadata: [read_only: true]
-
-      config :ecto, Repo,
-        log_level: :info,
-        pool_size: 10,
-        metadata: [replica: true]
-
-  will have a final value of the configuration for the `Repo`
-  key in the `:ecto` application of:
-
-      Application.get_env(:ecto, Repo)
-      #=> [
-      #=>   log_level: :info,
-      #=>   pool_size: 10,
-      #=>   adapter: Ecto.Adapters.Postgres,
-      #=>   metadata: [read_only: true, replica: true]
-      #=> ]
-
-  """
-  @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 """
-  Returns the environment this configuration file is executed on.
-
-  In Mix projects this function returns the environment this configuration
-  file is executed on. In releases, the environment when `mix release` ran.
-
-  This is most often used to execute conditional code:
-
-      if config_env() == :prod do
-        config :my_app, :debug, false
-      end
-
-  """
-  @doc since: "1.11.0"
-  defmacro config_env() do
-    quote do
-      Config.__env__!()
-    end
-  end
-
-  @doc false
-  @spec __env__!() :: atom()
-  def __env__!() do
-    elem(get_opts!(), 0) || raise "no :env key was given to this configuration file"
-  end
-
-  @doc """
-  Returns the target this configuration file is executed on.
-
-  This is most often used to execute conditional code:
-
-      if config_target() == :host do
-        config :my_app, :debug, false
-      end
-
-  """
-  @doc since: "1.11.0"
-  defmacro config_target() do
-    quote do
-      Config.__target__!()
-    end
-  end
-
-  @doc false
-  @spec __target__!() :: atom()
-  def __target__!() do
-    elem(get_opts!(), 1) || raise "no :target key was given to this configuration file"
-  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 "#{config_env()}.exs"
-
-  Note, however, some configuration files, such as `config/runtime.exs`
-  does not support imports, as they are meant to be copied across
-  systems.
-  """
-  @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
-    import_config!(file, File.read!(file), true)
-  end
-
-  @doc false
-  @spec __eval__!(Path.t(), binary(), keyword) :: {keyword, [Path.t()] | :disabled}
-  def __eval__!(file, content, opts \\ []) when is_binary(file) and is_list(opts) do
-    env = Keyword.get(opts, :env)
-    target = Keyword.get(opts, :target)
-    imports = Keyword.get(opts, :imports, [])
-
-    previous_opts = put_opts({env, target})
-    previous_config = put_config([])
-    previous_imports = put_imports(imports)
-
-    try do
-      {eval_config, _} = import_config!(file, content, false)
-
-      case get_config!() do
-        [] when is_list(eval_config) ->
-          {validate!(eval_config, file), get_imports!()}
-
-        pdict_config ->
-          {pdict_config, get_imports!()}
-      end
-    after
-      if previous_opts, do: put_opts(previous_opts), else: delete_opts()
-      if previous_config, do: put_config(previous_config), else: delete_config()
-      if previous_imports, do: put_imports(previous_imports), else: delete_imports()
-    end
-  end
-
-  defp import_config!(file, contents, raise_when_disabled?) do
-    current_imports = get_imports!()
-
-    cond do
-      current_imports == :disabled ->
-        if raise_when_disabled? do
-          raise "import_config/1 is not enabled for this configuration file. " <>
-                  "Some configuration files do not allow importing other files " <>
-                  "as they are often copied to external systems"
-        end
-
-      file in current_imports ->
-        raise ArgumentError,
-              "attempting to load configuration #{Path.relative_to_cwd(file)} recursively"
-
-      true ->
-        put_imports([file | current_imports])
-        :ok
-    end
-
-    Code.eval_string(contents, [], file: file)
-  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,415 +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`.
-
-  ## Multiple config files
-
-  One common use of config providers is to specify multiple
-  configuration files in a release. Elixir ships with one provider,
-  called `Config.Reader`, which is capable of handling Elixir's
-  built-in config files.
-
-  For example, imagine you want to list some basic configuration
-  on Mix's built-in `config/runtime.exs` file, but you also want
-  to support additional configuration files. To do so, you can add
-  this inside the `def project` portion of  your `mix.exs`:
-
-      releases: [
-        demo: [
-          config_providers: [
-            {Config.Reader, {:system, "RELEASE_ROOT", "/extra_config.exs"}}
-          ]
-        ]
-      ]
-
-  You can place this `extra_config.exs` file in your release in
-  multiple ways:
-
-    1. If it is available on the host when assembling the release,
-      you can place it on "rel/overlays/extra_config.exs" and it
-      will be automatically copied to the release root
-
-    2. If it is available on the target during deployment, you can
-      simply copy it to the release root as a step in your deployment
-
-  Now once the system boots, it will load both `config/runtime.exs`
-  and `extra_config.exs` early in the boot process. You can learn
-  more options on `Config.Reader`.
-
-  ## Custom config provider
-
-  You can also implement custom config providers, similar to how
-  `Config.Reader` works. 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
-        @impl true
-        def init(path) when is_binary(path), do: path
-
-        @impl true
-        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"}
-          ]
-        ]
-      ]
-
-  """
-
-  @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_runtime_sys_config_after_boot: false,
-    reboot_system_after_config: false,
-    validate_compile_env: false
-  ]
-
-  @reserved_apps [:kernel, :stdlib]
-
-  @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
-
-  # Private keys
-  @init_key :config_provider_init
-  @booted_key :config_provider_booted
-
-  # Public keys
-  @reboot_mode_key :config_provider_reboot_mode
-
-  @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)}
-    init = struct!(%Config.Provider{config_path: config_path, providers: providers}, opts)
-    [elixir: [{@init_key, init}]]
-  end
-
-  @doc false
-  def boot(reboot_fun \\ &restart_and_sleep/0) do
-    # 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)
-
-    case Application.fetch_env(:elixir, @booted_key) do
-      {:ok, {:booted, path}} ->
-        path && File.rm(path)
-
-        with {:ok, %Config.Provider{} = provider} <- Application.fetch_env(:elixir, @init_key) do
-          maybe_validate_compile_env(provider)
-        end
-
-        :booted
-
-      _ ->
-        case Application.fetch_env(:elixir, @init_key) do
-          {:ok, %Config.Provider{} = provider} ->
-            path = resolve_config_path!(provider.config_path)
-            reboot_config = [elixir: [{@booted_key, booted_value(provider, path)}]]
-            boot_providers(path, provider, reboot_config, reboot_fun)
-
-          _ ->
-            :skip
-        end
-    end
-  end
-
-  defp boot_providers(path, provider, reboot_config, reboot_fun) do
-    original_config = read_config!(path)
-
-    config =
-      original_config
-      |> Config.__merge__(provider.extra_config)
-      |> run_providers(provider)
-
-    if provider.reboot_system_after_config do
-      config
-      |> Config.__merge__(reboot_config)
-      |> write_config!(path)
-
-      reboot_fun.()
-    else
-      for app <- @reserved_apps, config[app] != original_config[app] do
-        abort("""
-        Cannot configure #{inspect(app)} because :reboot_system_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, ensure_loaded? \\ true) do
-    for {app, [key | path], compile_return} <- compile_env,
-        ensure_app_loaded?(app, ensure_loaded?) 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 ensure_app_loaded?(app, true), do: Application.ensure_loaded(app) == :ok
-  defp ensure_app_loaded?(app, false), do: Application.spec(app, :vsn) != nil
-
-  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)
-
-  @compile {:no_warn_undefined, {:init, :restart, 1}}
-  defp restart_and_sleep() do
-    mode = Application.get_env(:elixir, @reboot_mode_key)
-
-    if mode in [:embedded, :interactive] do
-      :init.restart(mode: mode)
-    else
-      :init.restart()
-    end
-
-    Process.sleep(:infinity)
-  end
-
-  defp booted_value(%{prune_runtime_sys_config_after_boot: true}, path), do: {:booted, path}
-  defp booted_value(%{prune_runtime_sys_config_after_boot: false}, _path), do: {:booted, nil}
-
-  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("ERROR! " <> msg)
-    :erlang.raise(:error, "aborting boot", [{Config.Provider, :boot, 2, []}])
-  end
-end

lib/elixir/lib/config/reader.ex

@@ -1,138 +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`. A config
-  provider is used during releases to customize how applications are
-  configured. 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 add this inside the `def project` portion
-  of  your `mix.exs`:
-
-      releases: [
-        demo: [
-          config_providers: [
-            {Config.Reader, "/etc/config.exs"}
-          ]
-        ]
-      ]
-
-  Or if you want to read a custom path inside the release:
-
-      config_providers: [{Config.Reader, {:system, "RELEASE_ROOT", "/config.exs"}}]
-
-  You can also pass a keyword list of options to the reader,
-  where the `:path` is a required key:
-
-      config_providers: [
-        {Config.Reader,
-         path: "/etc/config.exs",
-         env: :prod,
-         imports: :disabled}
-      ]
-
-  Remember Mix already loads `config/runtime.exs` by default.
-  For more examples and scenarios, see the `Config.Provider` module.
-  """
-
-  @behaviour Config.Provider
-
-  @impl true
-  def init(opts) when is_list(opts) do
-    {path, opts} = Keyword.pop!(opts, :path)
-    Config.Provider.validate_config_path!(path)
-    {path, opts}
-  end
-
-  def init(path) do
-    init(path: path)
-  end
-
-  @impl true
-  def load(config, {path, opts}) do
-    merge(config, path |> Config.Provider.resolve_config_path!() |> read!(opts))
-  end
-
-  @doc """
-  Evaluates the configuration `contents` for the given `file`.
-
-  Accepts the same options as `read!/2`.
-  """
-  @doc since: "1.11.0"
-  @spec eval!(Path.t(), binary, keyword) :: keyword
-  def eval!(file, contents, opts \\ [])
-      when is_binary(file) and is_binary(contents) and is_list(opts) do
-    Config.__eval__!(Path.expand(file), contents, opts) |> elem(0)
-  end
-
-  @doc """
-  Reads the configuration file.
-
-  ## Options
-
-    * `:imports` - a list of already imported paths or `:disabled`
-      to disable imports
-
-    * `:env` - the environment the configuration file runs on.
-      See `Config.config_env/0` for sample usage
-
-    * `:target` - the target the configuration file runs on.
-      See `Config.config_target/0` for sample usage
-
-  """
-  @doc since: "1.9.0"
-  @spec read!(Path.t(), keyword) :: keyword
-  def read!(file, opts \\ []) when is_binary(file) and is_list(opts) do
-    file = Path.expand(file)
-    Config.__eval__!(file, File.read!(file), opts) |> elem(0)
-  end
-
-  @doc """
-  Reads the given configuration file and returns the configuration
-  with its imports.
-
-  Accepts the same options as `read!/2`. Although note the `:imports`
-  option cannot be disabled in `read_imports!/2`.
-  """
-  @doc since: "1.9.0"
-  @spec read_imports!(Path.t(), keyword) :: {keyword, [Path.t()]}
-  def read_imports!(file, opts \\ []) when is_binary(file) and is_list(opts) do
-    if opts[:imports] == :disabled do
-      raise ArgumentError, ":imports must be a list of paths"
-    end
-
-    file = Path.expand(file)
-    Config.__eval__!(file, File.read!(file), opts)
-  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,27 +9,18 @@ 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"
+  # TODO: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
 
   defmacro __using__(_) do
     # Use this import to guarantee proper code expansion
     import Kernel, except: [size: 1]
 
-    if __CALLER__.module != HashDict do
-      IO.warn("use Dict is deprecated. " <> unquote(message), __CALLER__)
-    end
-
     quote do
-      message = "Use maps and the Map module instead"
-
-      @deprecated message
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -37,7 +28,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
@@ -45,14 +35,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
@@ -60,33 +48,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
@@ -96,49 +79,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]
 
@@ -150,182 +125,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, default, fun) do
+      def update(dict, key, initial, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
-
           :error ->
-            put(dict, key, default)
+            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)
@@ -334,11 +271,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)
@@ -352,61 +288,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, default, fun) do
-    target(dict).update(dict, key, default, fun)
+  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)
@@ -417,20 +343,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)
@@ -438,6 +362,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
@@ -42,7 +41,6 @@ defmodule File.Stream do
       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.
@@ -74,19 +70,19 @@ defmodule File.Stream 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
-
-          {:error, reason} ->
-            raise File.Error, reason: reason, action: "stream", path: path
+      start_fun =
+        fn ->
+          case :file.open(path, read_modes(modes)) do
+            {:ok, device} ->
+              if :trim_bom in modes, do: trim_bom(device), else: 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
 
@@ -100,70 +96,44 @@ defmodule File.Stream do
       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
+    def count(%{path: path, line_or_bytes: bytes}) 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)}
-
+          {:ok, div(size, bytes) + if(rem(size, bytes) == 0, do: 0, else: 1)}
         {:error, reason} ->
           raise File.Error, reason: reason, action: "stream", path: path
       end
     end
 
-    def count(_stream) do
-      {:error, __MODULE__}
-    end
-
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
 
-    def slice(_stream) do
-      {:error, __MODULE__}
+    defp trim_bom(device) do
+      header = IO.binread(device, 4)
+      {:ok, _new_pos} = :file.position(device, bom_length(header))
+      device
     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 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
@@ -173,10 +143,8 @@ defmodule File.Stream 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

lib/elixir/lib/float.ex

@@ -3,114 +3,14 @@ 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 arithmetic 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/)
-
   """
 
   import Bitwise
 
-  @power_of_2_to_52 4_503_599_627_370_496
+  @power_of_2_to_52 4503599627370496
   @precision_range 0..15
   @type precision_range :: 0..15
 
-  @min_finite then(<<0xFFEFFFFFFFFFFFFF::64>>, fn <<num::float>> -> num end)
-  @max_finite then(<<0x7FEFFFFFFFFFFFFF::64>>, fn <<num::float>> -> num end)
-
-  @doc """
-  Returns the maximum finite value for a float.
-
-  ## Examples
-
-      iex> Float.max_finite()
-      1.7976931348623157e308
-
-  """
-  def max_finite, do: @max_finite
-
-  @doc """
-  Returns the minimum finite value for a float.
-
-  ## Examples
-
-      iex> Float.min_finite()
-      -1.7976931348623157e308
-
-  """
-  def min_finite, do: @min_finite
-
-  @doc """
-  Computes `base` raised to power of `exponent`.
-
-  `base` must be a float and `exponent` can be any number.
-  However, if a negative base and a fractional exponent
-  are given, it raises `ArithmeticError`.
-
-  It always returns a float. See `Integer.pow/2` for
-  exponentiation that returns integers.
-
-  ## Examples
-
-      iex> Float.pow(2.0, 0)
-      1.0
-      iex> Float.pow(2.0, 1)
-      2.0
-      iex> Float.pow(2.0, 10)
-      1024.0
-      iex> Float.pow(2.0, -1)
-      0.5
-      iex> Float.pow(2.0, -3)
-      0.125
-
-      iex> Float.pow(3.0, 1.5)
-      5.196152422706632
-
-      iex> Float.pow(-2.0, 3)
-      -8.0
-      iex> Float.pow(-2.0, 4)
-      16.0
-
-      iex> Float.pow(-1.0, 0.5)
-      ** (ArithmeticError) bad argument in arithmetic expression
-
-  """
-  @doc since: "1.12.0"
-  @spec pow(float, number) :: float
-  def pow(base, exponent) when is_float(base) and is_number(exponent),
-    do: :math.pow(base, exponent)
-
   @doc """
   Parses a binary into a float.
 
@@ -119,8 +19,7 @@ defmodule Float do
   returned.
 
   If the size of float exceeds the maximum size of `1.7976931348623157e+308`,
-  `:error` is returned even though the textual representation itself might be
-  well formed.
+  the `ArgumentError` exception is raised.
 
   If you want to convert a string-formatted float directly to a float,
   `String.to_float/1` can be used instead.
@@ -136,8 +35,6 @@ defmodule Float do
 
       iex> Float.parse("pi")
       :error
-      iex> Float.parse("1.7976931348623159e+308")
-      :error
 
   """
   @spec parse(binary) :: {float, binary} | :error
@@ -156,55 +53,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>>)
 
-  # When floats are expressed in scientific notation, :erlang.binary_to_float/1 can raise an
-  # ArgumentError if the e exponent is too big. For example, "1.0e400". Because of this, we
-  # rescue the ArgumentError here and return an error.
-  defp parse_unsigned(rest, dot?, true = _e?, acc) do
-    :erlang.binary_to_float(add_dot(acc, dot?))
-  rescue
-    ArgumentError -> :error
-  else
-    float -> {float, rest}
-  end
+  defp parse_unsigned(rest, dot?, _e?, acc), do:
+    {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
 
-  defp parse_unsigned(rest, dot?, false = _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
   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)
@@ -215,6 +95,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)
@@ -228,10 +111,6 @@ defmodule Float do
   @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
     round(number, precision, :floor)
   end
@@ -275,10 +154,6 @@ defmodule Float do
   @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
     round(number, precision, :ceil)
   end
@@ -298,8 +173,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)
@@ -335,36 +208,32 @@ defmodule Float do
   # 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
     round(float, precision, :half_up)
   end
 
-  def round(float, precision) when is_float(float) do
+  def round(number, precision) when is_float(number) do
     raise ArgumentError, invalid_precision_message(precision)
   end
 
-  defp round(0.0 = num, _precision, _rounding), do: num
-
   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 ->
@@ -384,18 +253,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)
@@ -403,28 +270,11 @@ defmodule Float do
     end
   end
 
-  defp decompose(significant, initial) do
-    decompose(significant, 1, 0, initial)
-  end
-
-  defp decompose(<<1::1, bits::bitstring>>, count, last_count, acc) do
-    decompose(bits, count + 1, count, (acc <<< (count - last_count)) + 1)
-  end
-
-  defp decompose(<<0::1, bits::bitstring>>, count, last_count, acc) do
-    decompose(bits, count + 1, last_count, acc)
-  end
-
-  defp decompose(<<>>, _count, last_count, acc) do
-    {acc, last_count}
-  end
-
   defp scale_up(num, boundary, exp) when num >= boundary, do: {num, exp}
   defp scale_up(num, boundary, exp), do: scale_up(num <<< 1, boundary, exp - 1)
 
   defp scale_down(num, den, exp) do
     new_den = den <<< 1
-
     if num < new_den do
       {den >>> 52, exp}
     else
@@ -445,31 +295,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
@@ -477,8 +325,6 @@ defmodule Float do
 
   ## Examples
 
-      iex> Float.ratio(0.0)
-      {0, 1}
       iex> Float.ratio(3.14)
       {7070651414971679, 2251799813685248}
       iex> Float.ratio(-3.14)
@@ -493,75 +339,53 @@ 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
-    <<sign::1, exp::11, mantissa::52>> = <<float::float>>
-
-    {num, den_exp} =
-      if exp != 0 do
-        # Floats are expressed like this:
-        # (2**52 + mantissa) * 2**(-52 + exp - 1023)
-        #
-        # We compute the root factors of the mantissa so we have this:
-        # (2**52 + mantissa * 2**count) * 2**(-52 + exp - 1023)
-        {mantissa, count} = root_factors(mantissa, 0)
-
-        # Now we can move the count around so we have this:
-        # (2**(52-count) + mantissa) * 2**(count + -52 + exp - 1023)
-        if mantissa == 0 do
-          {1, exp - 1023}
-        else
-          num = (1 <<< (52 - count)) + mantissa
-          den_exp = count - 52 + exp - 1023
-          {num, den_exp}
-        end
-      else
-        # Subnormals are expressed like this:
-        # (mantissa) * 2**(-52 + 1 - 1023)
-        #
-        # So we compute it to this:
-        # (mantissa * 2**(count)) * 2**(-52 + 1 - 1023)
-        #
-        # Which becomes:
-        # mantissa * 2**(count-1074)
-        root_factors(mantissa, -1074)
-      end
-
-    if den_exp > 0 do
-      {sign(sign, num <<< den_exp), 1}
-    else
-      {sign(sign, num), 1 <<< -den_exp}
+    <<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 root_factors(mantissa, count) when mantissa != 0 and (mantissa &&& 1) == 0,
-    do: root_factors(mantissa >>> 1, count + 1)
+  defp decompose(significant) do
+    decompose(significant, 1, 0, 2, 1, 1)
+  end
 
-  defp root_factors(mantissa, count),
-    do: {mantissa, count}
+  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}
   defp sign(0, num), do: num
   defp sign(1, num), do: -num
 
+  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}
+  defp shift_right(num, times), do: shift_right(num >>> 1, times - 1)
+
   @doc """
-  Returns a charlist which corresponds to the shortest text representation
+  Returns a charlist which corresponds to the text representation
   of the given float.
 
-  The underlying algorithm changes depending on the Erlang/OTP version:
-
-    * For OTP >= 24, it uses the algorithm presented in "Ryū: fast
-      float-to-string conversion" in Proceedings of the SIGPLAN '2018
-      Conference on Programming Language Design and Implementation.
-
-    * For OTP < 24, it uses the algorithm presented in "Printing Floating-Point
-      Numbers Quickly and Accurately" in Proceedings of the SIGPLAN '1996
-      Conference on Programming Language Design and Implementation.
-
-  For a configurable representation, use `:erlang.float_to_list/2`.
+  It uses the shortest representation according to algorithm described
+  in "Printing Floating-Point Numbers Quickly and Accurately" in
+  Proceedings of the SIGPLAN '96 Conference on Programming Language
+  Design and Implementation.
 
   ## Examples
 
@@ -575,20 +399,13 @@ defmodule Float do
   end
 
   @doc """
-  Returns a binary which corresponds to the shortest text representation
+  Returns a binary which corresponds to the text representation
   of the given float.
 
-  The underlying algorithm changes depending on the Erlang/OTP version:
-
-    * For OTP >= 24, it uses the algorithm presented in "Ryū: fast
-      float-to-string conversion" in Proceedings of the SIGPLAN '2018
-      Conference on Programming Language Design and Implementation.
-
-    * For OTP < 24, it uses the algorithm presented in "Printing Floating-Point
-      Numbers Quickly and Accurately" in Proceedings of the SIGPLAN '1996
-      Conference on Programming Language Design and Implementation.
-
-  For a configurable representation, use `:erlang.float_to_binary/2`.
+  It uses the shortest representation according to algorithm described
+  in "Printing Floating-Point Numbers Quickly and Accurately" in
+  Proceedings of the SIGPLAN '96 Conference on Programming Language
+  Design and Implementation.
 
   ## Examples
 
@@ -596,33 +413,36 @@ 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: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
   @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"
+  # TODO: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
   def to_char_list(float, options) do
     :erlang.float_to_list(float, expand_compact(options))
   end
 
   @doc false
-  @deprecated "Use :erlang.float_to_binary/2 instead"
+  # TODO: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
   def to_string(float, options) do
     :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)}"
+    "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,208 +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
-
-  Anonymous functions can also have multiple clauses. All clauses
-  should expect the same number of arguments:
-
-      iex> negate = fn
-      ...>   true -> false
-      ...>   false -> true
-      ...> end
-      iex> negate.(false)
-      true
-
-  ## The capture operator
-
-  It is also possible to capture public 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
-
-  To capture a definition within the current module, you can skip the
-  module prefix, such as `&my_fun/2`. In those cases, the captured
-  function can be public (`def`) or private (`defp`).
-
-  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`.
-
-  ## Internal and external functions
-
-  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.ex

@@ -1,13 +1,15 @@
 defmodule GenEvent do
+  # TODO: Remove by 2.0
+
   # Functions from this module are deprecated in elixir_dispatch.
 
   @moduledoc """
-  An event manager with event handlers behaviour.
+  WARNING: this module is deprecated.
 
   If you are interested in implementing an event manager, please read the
   "Alternatives" section below. If you have to implement an event handler to
   integrate with an existing system, such as Elixir's Logger, please use
-  [`:gen_event`](`:gen_event`) instead.
+  `:gen_event` instead.
 
   ## Alternatives
 
@@ -30,7 +32,7 @@ defmodule GenEvent do
   If the use case where you were using GenEvent requires more complex logic,
   [GenStage](https://github.com/elixir-lang/gen_stage) provides a great
   alternative. GenStage is an external Elixir library maintained by the Elixir
-  team; it provides a tool to implement systems that exchange events in a
+  team; it provides tool to implement systems that exchange events in a
   demand-driven way with built-in support for backpressure. See the [GenStage
   documentation](https://hexdocs.pm/gen_stage) for more information.
 
@@ -38,40 +40,34 @@ defmodule GenEvent do
 
   If your use case requires exactly what GenEvent provided, or you have to
   integrate with an existing `:gen_event`-based system, you can still use the
-  [`:gen_event`](`:gen_event`) Erlang module.
+  [`:gen_event`](http://erlang.org/doc/man/gen_event.html) Erlang module.
   """
 
-  @moduledoc deprecated: "Use Erlang/OTP's :gen_event module instead"
-
   @callback init(args :: term) ::
-              {:ok, state}
-              | {:ok, state, :hibernate}
-              | {:error, reason :: any}
-            when state: any
+    {:ok, state} |
+    {:ok, state, :hibernate} |
+    {:error, reason :: any} when state: any
 
   @callback handle_event(event :: term, state :: term) ::
-              {:ok, new_state}
-              | {:ok, new_state, :hibernate}
-              | :remove_handler
-            when new_state: term
+    {:ok, new_state} |
+    {:ok, new_state, :hibernate} |
+    :remove_handler when new_state: term
 
   @callback handle_call(request :: term, state :: term) ::
-              {:ok, reply, new_state}
-              | {:ok, reply, new_state, :hibernate}
-              | {:remove_handler, reply}
-            when reply: term, new_state: term
+    {:ok, reply, new_state} |
+    {:ok, reply, new_state, :hibernate} |
+    {:remove_handler, reply} when reply: term, new_state: term
 
   @callback handle_info(msg :: term, state :: term) ::
-              {:ok, new_state}
-              | {:ok, new_state, :hibernate}
-              | :remove_handler
-            when new_state: term
+    {:ok, new_state} |
+    {:ok, new_state, :hibernate} |
+    :remove_handler when new_state: term
 
-  @callback terminate(reason, state :: term) :: term
-            when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term
+  @callback terminate(reason, state :: term) ::
+    term when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term
 
-  @callback code_change(old_vsn, state :: term, extra :: term) :: {:ok, new_state :: term}
-            when old_vsn: term | {:down, term}
+  @callback code_change(old_vsn, state :: term, extra :: term) ::
+    {:ok, new_state :: term} when old_vsn: term | {:down, term}
 
   @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}
 
@@ -83,15 +79,11 @@ defmodule GenEvent do
 
   @type handler :: atom | {atom, term}
 
-  message = "Use one of the alternatives described in the documentation for the GenEvent module"
-
-  @deprecated message
   @doc false
   defmacro __using__(_) do
-    deprecation_message =
-      "the GenEvent module is deprecated, see its documentation for alternatives"
-
-    IO.warn(deprecation_message, __CALLER__)
+    %{file: file, line: line} = __CALLER__
+    deprecation_message = "the GenEvent module is deprecated, see its documentation for alternatives"
+    :elixir_errors.warn(line, file, deprecation_message)
 
     quote location: :keep do
       @behaviour :gen_event
@@ -110,17 +102,14 @@ defmodule GenEvent do
       def handle_call(msg, state) do
         proc =
           case Process.info(self(), :registered_name) do
-            {_, []} -> self()
+            {_, []}   -> self()
             {_, name} -> name
           end
 
         # We do this to trick Dialyzer to not complain about non-local returns.
         case :erlang.phash2(1, 1) do
-          0 ->
-            raise "attempted to call GenEvent #{inspect(proc)} but no handle_call/2 clause was provided"
-
-          1 ->
-            {:remove_handler, {:bad_call, msg}}
+          0 -> raise "attempted to call GenEvent #{inspect proc} but no handle_call/2 clause was provided"
+          1 -> {:remove_handler, {:bad_call, msg}}
         end
       end
 
@@ -139,24 +128,18 @@ defmodule GenEvent do
         {:ok, state}
       end
 
-      defoverridable init: 1,
-                     handle_event: 2,
-                     handle_call: 2,
-                     handle_info: 2,
-                     terminate: 2,
-                     code_change: 3
+      defoverridable [init: 1, handle_event: 2, handle_call: 2,
+                      handle_info: 2, terminate: 2, code_change: 3]
     end
   end
 
   @doc false
-  @deprecated message
   @spec start_link(options) :: on_start
   def start_link(options \\ []) when is_list(options) do
     do_start(:link, options)
   end
 
   @doc false
-  @deprecated message
   @spec start(options) :: on_start
   def start(options \\ []) when is_list(options) do
     do_start(:nolink, options)
@@ -168,19 +151,15 @@ defmodule GenEvent do
     case Keyword.get(options, :name) do
       nil ->
         :gen.start(GenEvent, mode, @no_callback, [], [])
-
       atom when is_atom(atom) ->
         :gen.start(GenEvent, mode, {:local, atom}, @no_callback, [], [])
-
       {:global, _term} = tuple ->
         :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
-
       {:via, via_module, _term} = tuple when is_atom(via_module) ->
         :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
-
       other ->
         raise ArgumentError, """
-        expected :name option to be one of the following:
+        expected :name option to be one of:
 
           * nil
           * atom
@@ -193,28 +172,26 @@ defmodule GenEvent do
   end
 
   @doc false
-  @deprecated message
-  @spec stream(manager, keyword) :: GenEvent.Stream.t()
+  @spec stream(manager, keyword) :: GenEvent.Stream.t
   def stream(manager, options \\ []) do
-    %GenEvent.Stream{manager: manager, timeout: Keyword.get(options, :timeout, :infinity)}
+    %GenEvent.Stream{
+      manager: manager,
+      timeout: Keyword.get(options, :timeout, :infinity)}
   end
 
   @doc false
-  @deprecated message
   @spec add_handler(manager, handler, term) :: :ok | {:error, term}
   def add_handler(manager, handler, args) do
     rpc(manager, {:add_handler, handler, args})
   end
 
   @doc false
-  @deprecated message
   @spec add_mon_handler(manager, handler, term) :: :ok | {:error, term}
   def add_mon_handler(manager, handler, args) do
     rpc(manager, {:add_mon_handler, handler, args, self()})
   end
 
   @doc false
-  @deprecated message
   @spec notify(manager, term) :: :ok
   def notify(manager, event)
 
@@ -239,28 +216,26 @@ defmodule GenEvent do
   def notify(manager, msg)
       when is_pid(manager)
       when is_atom(manager)
-      when tuple_size(manager) == 2 and is_atom(elem(manager, 0)) and is_atom(elem(manager, 1)) do
+      when tuple_size(manager) == 2 and
+        is_atom(elem(manager, 0)) and is_atom(elem(manager, 1)) do
     send(manager, {:notify, msg})
     :ok
   end
 
   @doc false
-  @deprecated message
   @spec sync_notify(manager, term) :: :ok
   def sync_notify(manager, event) do
     rpc(manager, {:sync_notify, event})
   end
 
   @doc false
-  @deprecated message
   @spec ack_notify(manager, term) :: :ok
   def ack_notify(manager, event) do
     rpc(manager, {:ack_notify, event})
   end
 
   @doc false
-  @deprecated message
-  @spec call(manager, handler, term, timeout) :: term | {:error, term}
+  @spec call(manager, handler, term, timeout) ::  term | {:error, term}
   def call(manager, handler, request, timeout \\ 5000) do
     try do
       :gen.call(manager, self(), {:call, handler, request}, timeout)
@@ -273,35 +248,30 @@ defmodule GenEvent do
   end
 
   @doc false
-  @deprecated message
   @spec remove_handler(manager, handler, term) :: term | {:error, term}
   def remove_handler(manager, handler, args) do
     rpc(manager, {:delete_handler, handler, args})
   end
 
   @doc false
-  @deprecated message
   @spec swap_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
   def swap_handler(manager, handler1, args1, handler2, args2) do
     rpc(manager, {:swap_handler, handler1, args1, handler2, args2})
   end
 
   @doc false
-  @deprecated message
   @spec swap_mon_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
   def swap_mon_handler(manager, handler1, args1, handler2, args2) do
     rpc(manager, {:swap_mon_handler, handler1, args1, handler2, args2, self()})
   end
 
   @doc false
-  @deprecated message
   @spec which_handlers(manager) :: [handler]
   def which_handlers(manager) do
     rpc(manager, :which_handlers)
   end
 
   @doc false
-  @deprecated message
   @spec stop(manager, reason :: term, timeout) :: :ok
   def stop(manager, reason \\ :normal, timeout \\ :infinity) do
     :gen.stop(manager, reason, timeout)
@@ -315,7 +285,7 @@ defmodule GenEvent do
   ## Init callbacks
 
   require Record
-  Record.defrecordp(:handler, [:module, :id, :state, :pid, :ref])
+  Record.defrecordp :handler, [:module, :id, :state, :pid, :ref]
 
   @doc false
   def init_it(starter, :self, name, mod, args, options) do
@@ -324,7 +294,12 @@ defmodule GenEvent do
 
   def init_it(starter, parent, name, _mod, _args, options) do
     Process.put(:"$initial_call", {__MODULE__, :init_it, 6})
-    debug = :gen.debug_options(name, options)
+    debug =
+      if function_exported?(:gen, :debug_options, 2) do
+        :gen.debug_options(name, options)
+      else
+        :gen.debug_options(options)
+      end
     :proc_lib.init_ack(starter, {:ok, self()})
     loop(parent, name(name), [], debug, false)
   end
@@ -334,7 +309,7 @@ defmodule GenEvent do
     fetch_msg(parent, name, handlers, debug, true)
   end
 
-  defp name({:local, name}), do: name
+  defp name({:local, name}),  do: name
   defp name({:global, name}), do: name
   defp name({:via, _, name}), do: name
   defp name(pid) when is_pid(pid), do: pid
@@ -352,14 +327,12 @@ defmodule GenEvent do
   defp fetch_msg(parent, name, handlers, debug, hib) do
     receive do
       {:system, from, req} ->
-        :sys.handle_system_msg(req, from, parent, __MODULE__, debug, [name, handlers, hib], hib)
-
+        :sys.handle_system_msg(req, from, parent, __MODULE__,
+          debug, [name, handlers, hib], hib)
       {:EXIT, ^parent, reason} ->
         server_terminate(reason, parent, handlers, name)
-
       msg when debug == [] ->
         handle_msg(msg, parent, name, handlers, [])
-
       msg ->
         debug = :sys.handle_debug(debug, &print_event/3, name, {:in, msg})
         handle_msg(msg, parent, name, handlers, debug)
@@ -371,78 +344,59 @@ defmodule GenEvent do
       {:notify, event} ->
         {hib, handlers} = server_event(:async, event, handlers, name)
         loop(parent, name, handlers, debug, hib)
-
       {_from, _tag, {:notify, event}} ->
         {hib, handlers} = server_event(:async, event, handlers, name)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:ack_notify, event}} ->
         reply(tag, :ok)
         {hib, handlers} = server_event(:ack, event, handlers, name)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:sync_notify, event}} ->
         {hib, handlers} = server_event(:sync, event, handlers, name)
         reply(tag, :ok)
         loop(parent, name, handlers, debug, hib)
-
       {:DOWN, ref, :process, _pid, reason} = other ->
         case handle_down(ref, reason, handlers, name) do
           {:ok, handlers} ->
             loop(parent, name, handlers, debug, false)
-
           :error ->
             {hib, handlers} = server_info(other, handlers, name)
             loop(parent, name, handlers, debug, hib)
         end
-
       {_from, tag, {:call, handler, query}} ->
         {hib, reply, handlers} = server_call(handler, query, handlers, name)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:add_handler, handler, args}} ->
         {hib, reply, handlers} = server_add_handler(handler, args, handlers)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:add_mon_handler, handler, args, notify}} ->
         {hib, reply, handlers} = server_add_mon_handler(handler, args, handlers, notify)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:add_process_handler, pid, notify}} ->
         {hib, reply, handlers} = server_add_process_handler(pid, handlers, notify)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:delete_handler, handler, args}} ->
         {reply, handlers} = server_remove_handler(handler, args, handlers, name)
         reply(tag, reply)
         loop(parent, name, handlers, debug, false)
-
       {_from, tag, {:swap_handler, handler1, args1, handler2, args2}} ->
-        {hib, reply, handlers} =
-          server_swap_handler(handler1, args1, handler2, args2, handlers, nil, name)
-
+        {hib, reply, handlers} = server_swap_handler(handler1, args1, handler2, args2, handlers, nil, name)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, {:swap_mon_handler, handler1, args1, handler2, args2, mon}} ->
-        {hib, reply, handlers} =
-          server_swap_handler(handler1, args1, handler2, args2, handlers, mon, name)
-
+        {hib, reply, handlers} = server_swap_handler(handler1, args1, handler2, args2, handlers, mon, name)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
-
       {_from, tag, :which_handlers} ->
         reply(tag, server_which_handlers(handlers))
         loop(parent, name, handlers, debug, false)
-
       {_from, tag, :get_modules} ->
         reply(tag, server_get_modules(handlers))
         loop(parent, name, handlers, debug, false)
-
       other ->
         {hib, handlers} = server_info(other, handlers, name)
         loop(parent, name, handlers, debug, hib)
@@ -472,38 +426,31 @@ defmodule GenEvent do
           handler
         end
       end
-
     {:ok, [name, handlers, hib]}
   end
 
   @doc false
   def system_get_state([_name, handlers, _hib]) do
-    tuples =
-      for handler(module: mod, id: id, state: state) <- handlers do
-        {mod, id, state}
-      end
-
+    tuples = for handler(module: mod, id: id, state: state) <- handlers do
+      {mod, id, state}
+    end
     {:ok, tuples}
   end
 
   @doc false
   def system_replace_state(fun, [name, handlers, hib]) do
     {handlers, states} =
-      :lists.unzip(
-        for handler <- handlers do
-          handler(module: mod, id: id, state: state) = handler
-          cur = {mod, id, state}
-
-          try do
-            new = {^mod, ^id, new_state} = fun.(cur)
-            {handler(handler, state: new_state), new}
-          catch
-            _, _ ->
-              {handler, cur}
-          end
+      :lists.unzip(for handler <- handlers do
+        handler(module: mod, id: id, state: state) = handler
+        cur = {mod, id, state}
+        try do
+          new = {^mod, ^id, new_state} = fun.(cur)
+          {handler(handler, state: new_state), new}
+        catch
+          _, _ ->
+            {handler, cur}
         end
-      )
-
+      end)
     {:ok, states, [name, handlers, hib]}
   end
 
@@ -512,27 +459,23 @@ defmodule GenEvent do
     [pdict, sys_state, parent, _debug, [name, handlers, _hib]] = status_data
     header = :gen.format_status_header('Status for event handler', name)
 
-    formatted =
-      for handler <- handlers do
-        handler(module: module, state: state) = handler
-
-        if function_exported?(module, :format_status, 2) do
-          try do
-            state = module.format_status(opt, [pdict, state])
-            handler(handler, state: state)
-          catch
-            _, _ -> handler
-          end
-        else
-          handler
+    formatted = for handler <- handlers do
+      handler(module: module, state: state) = handler
+      if function_exported?(module, :format_status, 2) do
+        try do
+          state = module.format_status(opt, [pdict, state])
+          handler(handler, state: state)
+        catch
+          _, _ -> handler
         end
+      else
+        handler
       end
+    end
 
-    [
-      header: header,
-      data: [{'Status', sys_state}, {'Parent', parent}],
-      items: {'Installed handlers', formatted}
-    ]
+    [header: header,
+     data: [{'Status', sys_state}, {'Parent', parent}],
+     items: {'Installed handlers', formatted}]
   end
 
   ## Loop helpers
@@ -540,21 +483,16 @@ defmodule GenEvent do
   defp print_event(dev, {:in, msg}, name) do
     case msg do
       {:notify, event} ->
-        IO.puts(dev, "*DBG* #{inspect(name)} got event #{inspect(event)}")
-
+        IO.puts dev, "*DBG* #{inspect name} got event #{inspect event}"
       {_, _, {:call, handler, query}} ->
-        IO.puts(
-          dev,
-          "*DBG* #{inspect(name)} (handler #{inspect(handler)}) got call #{inspect(query)}"
-        )
-
+        IO.puts dev, "*DBG* #{inspect name} (handler #{inspect handler}) got call #{inspect query}"
       _ ->
-        IO.puts(dev, "*DBG* #{inspect(name)} got #{inspect(msg)}")
+        IO.puts dev, "*DBG* #{inspect name} got #{inspect msg}"
     end
   end
 
   defp print_event(dev, dbg, name) do
-    IO.puts(dev, "*DBG* #{inspect(name)}: #{inspect(dbg)}")
+    IO.puts dev, "*DBG* #{inspect name}: #{inspect dbg}"
   end
 
   defp server_add_handler({module, id}, args, handlers) do
@@ -581,7 +519,8 @@ defmodule GenEvent do
 
   defp server_add_process_handler(pid, handlers, notify) do
     ref = Process.monitor(pid)
-    handler = handler(module: GenEvent.Stream, id: {self(), ref}, pid: notify, ref: ref)
+    handler = handler(module: GenEvent.Stream, id: {self(), ref},
+                      pid: notify, ref: ref)
     do_add_handler(GenEvent.Stream, handler, {pid, ref}, handlers, {self(), ref})
   end
 
@@ -616,7 +555,6 @@ defmodule GenEvent do
       {pid, _ref} when is_pid(pid) ->
         server_process_notify(mode, event, handler)
         server_split_process_handlers(mode, event, t, handlers, [handler | streams])
-
       _ ->
         server_split_process_handlers(mode, event, t, [handler | handlers], streams)
     end
@@ -627,18 +565,17 @@ defmodule GenEvent do
   end
 
   defp server_process_notify(mode, event, handler(state: {pid, ref})) do
-    send(pid, {self(), {self(), ref}, {mode_to_tag(mode), event}})
+    send pid, {self(), {self(), ref}, {mode_to_tag(mode), event}}
   end
 
-  defp mode_to_tag(:ack), do: :ack_notify
-  defp mode_to_tag(:sync), do: :sync_notify
+  defp mode_to_tag(:ack),   do: :ack_notify
+  defp mode_to_tag(:sync),  do: :sync_notify
   defp mode_to_tag(:async), do: :notify
 
   defp server_notify(event, fun, [handler | t], name, handlers, acc, hib) do
     case server_update(handler, fun, event, name, handlers) do
       {new_hib, handler} ->
         server_notify(event, fun, t, name, handlers, [handler | acc], hib or new_hib)
-
       :error ->
         server_notify(event, fun, t, name, handlers, acc, hib)
     end
@@ -656,20 +593,16 @@ defmodule GenEvent do
         case res do
           {:ok, state} ->
             {false, handler(handler, state: state)}
-
           {:ok, state, :hibernate} ->
             {true, handler(handler, state: state)}
-
           :remove_handler ->
             do_terminate(handler, :remove_handler, event, name, :normal)
             :error
-
           other ->
             reason = {:bad_return_value, other}
             do_terminate(handler, {:error, reason}, event, name, reason)
             :error
         end
-
       {:error, reason} ->
         do_terminate(handler, {:error, reason}, event, name, reason)
         :error
@@ -680,19 +613,16 @@ defmodule GenEvent do
     server_collect_process_handlers(:async, event, t, [handler | handlers], name)
   end
 
-  defp server_collect_process_handlers(mode, event, [handler | t], handlers, name)
-       when mode in [:sync, :ack] do
+  defp server_collect_process_handlers(mode, event, [handler | t], handlers, name) when mode in [:sync, :ack] do
     handler(ref: ref, id: id) = handler
 
     receive do
       {^ref, :ok} ->
         server_collect_process_handlers(mode, event, t, [handler | handlers], name)
-
       {_from, tag, {:delete_handler, ^id, args}} ->
         do_terminate(handler, args, :remove, name, :normal)
         reply(tag, :ok)
         server_collect_process_handlers(mode, event, t, handlers, name)
-
       {:DOWN, ^ref, _, _, reason} ->
         do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)
         server_collect_process_handlers(mode, event, t, handlers, name)
@@ -707,12 +637,10 @@ defmodule GenEvent do
     case :lists.keyfind(module, handler(:id) + 1, handlers) do
       false ->
         {false, {:error, :not_found}, handlers}
-
       handler ->
         case server_call_update(handler, query, name, handlers) do
           {{hib, handler}, reply} ->
             {hib, reply, :lists.keyreplace(module, handler(:id) + 1, handlers, handler)}
-
           {:error, reply} ->
             {false, reply, :lists.keydelete(module, handler(:id) + 1, handlers)}
         end
@@ -721,26 +649,21 @@ defmodule GenEvent do
 
   defp server_call_update(handler, query, name, _handlers) do
     handler(module: module, state: state) = handler
-
     case do_handler(module, :handle_call, [query, state]) do
       {:ok, res} ->
         case res do
           {:ok, reply, state} ->
             {{false, handler(handler, state: state)}, reply}
-
           {:ok, reply, state, :hibernate} ->
             {{true, handler(handler, state: state)}, reply}
-
           {:remove_handler, reply} ->
             do_terminate(handler, :remove_handler, query, name, :normal)
             {:error, reply}
-
           other ->
             reason = {:bad_return_value, other}
             do_terminate(handler, {:error, reason}, query, name, reason)
             {:error, {:error, reason}}
         end
-
       {:error, reason} ->
         do_terminate(handler, {:error, reason}, query, name, reason)
         {:error, {:error, reason}}
@@ -748,9 +671,9 @@ defmodule GenEvent do
   end
 
   defp server_get_modules(handlers) do
-    for(handler(module: module) <- handlers, do: module)
-    |> :ordsets.from_list()
-    |> :ordsets.to_list()
+    (for handler(module: module) <- handlers, do: module)
+    |> :ordsets.from_list
+    |> :ordsets.to_list
   end
 
   defp server_which_handlers(handlers) do
@@ -762,19 +685,16 @@ defmodule GenEvent do
       for handler <- handlers do
         do_terminate(handler, :stop, :stop, name, :shutdown)
       end
-
     exit(reason)
   end
 
   defp reply({from, ref}, msg) do
-    send(from, {ref, msg})
+    send from, {ref, msg}
   end
 
   defp handle_down(ref, reason, handlers, name) do
     case :lists.keyfind(ref, handler(:ref) + 1, handlers) do
-      false ->
-        :error
-
+      false -> :error
       handler ->
         do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)
         {:ok, :lists.keydelete(ref, handler(:ref) + 1, handlers)}
@@ -789,21 +709,16 @@ defmodule GenEvent do
             case res do
               {:ok, state} ->
                 {false, succ, [handler(handler, state: state) | handlers]}
-
               {:ok, state, :hibernate} ->
                 {true, succ, [handler(handler, state: state) | handlers]}
-
               {:error, _} = error ->
                 {false, error, handlers}
-
               other ->
                 {false, {:error, {:bad_return_value, other}}, handlers}
             end
-
           {:error, _} = error ->
             {false, error, handlers}
         end
-
       _ ->
         {false, {:error, :already_present}, handlers}
     end
@@ -813,7 +728,6 @@ defmodule GenEvent do
     case :lists.keytake(module, handler(:id) + 1, handlers) do
       {:value, handler, handlers} ->
         {do_terminate(handler, args, last_in, name, reason), handlers}
-
       false ->
         {{:error, :not_found}, handlers}
     end
@@ -827,7 +741,6 @@ defmodule GenEvent do
         {:ok, res} -> res
         {:error, _} = error -> error
       end
-
     report_terminate(handler, reason, state, last_in, name)
     res
   end
@@ -837,8 +750,8 @@ defmodule GenEvent do
       apply(mod, fun, args)
     catch
       :throw, val -> {:ok, val}
-      :error, val -> {:error, {val, __STACKTRACE__}}
-      :exit, val -> {:error, val}
+      :error, val -> {:error, {val, System.stacktrace}}
+      :exit, val  -> {:error, val}
     else
       res -> {:ok, res}
     end
@@ -846,35 +759,29 @@ defmodule GenEvent do
 
   defp report_terminate(handler, reason, state, last_in, name) do
     report_error(handler, reason, state, last_in, name)
-
     if ref = handler(handler, :ref) do
       Process.demonitor(ref, [:flush])
     end
-
     if pid = handler(handler, :pid) do
-      send(pid, {:gen_event_EXIT, handler(handler, :id), reason})
+      send pid, {:gen_event_EXIT, handler(handler, :id), reason}
     end
   end
 
   defp report_error(_handler, :normal, _, _, _), do: :ok
   defp report_error(_handler, :shutdown, _, _, _), do: :ok
   defp report_error(_handler, {:swapped, _, _}, _, _, _), do: :ok
-
   defp report_error(handler, reason, state, last_in, name) do
     reason =
       case reason do
         {:undef, [{m, f, a, _} | _] = mfas} ->
           cond do
-            :code.is_loaded(m) == false ->
+            :code.is_loaded(m) === false ->
               {:"module could not be loaded", mfas}
-
             function_exported?(m, f, length(a)) ->
               reason
-
             true ->
               {:"function not exported", mfas}
           end
-
         _ ->
           reason
       end
@@ -883,10 +790,10 @@ defmodule GenEvent do
 
     :error_logger.error_msg(
       '** gen_event handler ~p crashed.~n' ++
-        '** Was installed in ~p~n' ++
-        '** Last event was: ~p~n' ++ '** When handler state == ~p~n' ++ '** Reason == ~p~n',
-      [handler(handler, :id), name, last_in, formatted, reason]
-    )
+      '** Was installed in ~p~n' ++
+      '** Last event was: ~p~n' ++
+      '** When handler state == ~p~n' ++
+      '** Reason == ~p~n', [handler(handler, :id), name, last_in, formatted, reason])
   end
 
   defp report_status(handler(module: module), state) do

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
@@ -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,12 @@
 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: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
 
   use Dict
 
@@ -22,70 +23,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, default, fun) when is_function(fun, 1) do
-    {root, counter} = do_update(root, key, fn -> default end, fun, key_hash(key))
+  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 +84,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,92 +92,74 @@ 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}
     end
   end
 
-  defp do_update(node, key, default, fun, hash) do
+  defp do_update(node, key, initial, fun, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
-        {put_elem(node, index, [key | default.()]), 1}
-
+        {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 | default.()])
+        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, default, fun, key_shift(hash))
+        {n, counter} = do_update(n, key, initial, fun, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
     end
   end
 
   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 +167,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 +196,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
@@ -277,24 +242,17 @@ defimpl Enumerable, for: HashDict do
     module = HashDict
     {:ok, module.size(dict)}
   end
-
-  def slice(_dict) do
-    {:error, __MODULE__}
-  end
 end
 
 defimpl Collectable, for: HashDict do
   def into(original) do
     # Avoid warnings about HashDict being deprecated.
     module = HashDict
-
-    collector_fun = fn
+    {original, fn
       dict, {:cont, {key, value}} -> module.put(dict, key, value)
       dict, :done -> dict
       _, :halt -> :ok
-    end
-
-    {original, collector_fun}
+    end}
   end
 end
 
@@ -304,6 +262,6 @@ defimpl Inspect, for: HashDict do
   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(module.to_list(dict), opts), ">"]
   end
 end

lib/elixir/lib/hash_set.ex

@@ -1,19 +1,18 @@
 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: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
 
   @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 +21,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 +93,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 +112,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 +138,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 +167,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 +211,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
@@ -287,24 +253,17 @@ defimpl Enumerable, for: HashSet do
     module = HashSet
     {:ok, module.size(set)}
   end
-
-  def slice(_set) do
-    {:error, __MODULE__}
-  end
 end
 
 defimpl Collectable, for: HashSet do
   def into(original) do
     # Avoid warnings about HashSet being deprecated.
     module = HashSet
-
-    collector_fun = fn
+    {original, fn
       set, {:cont, term} -> module.put(set, term)
       set, :done -> set
       _, :halt -> :ok
-    end
-
-    {original, collector_fun}
+    end}
   end
 end
 
@@ -314,6 +273,6 @@ defimpl Inspect, for: HashSet do
   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(module.to_list(set), opts), ">"]
   end
 end

lib/elixir/lib/inspect.ex

@@ -1,144 +1,60 @@
 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.
+  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.
 
-  This is typically done when you want to customize how your own
-  structs are inspected in logs and the terminal.
+  The `inspect/2` function receives the entity to be inspected
+  followed by the inspecting options, represented by the struct
+  `Inspect.Opts`.
 
-  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`.
+  Inspection is done using the functions available in `Inspect.Algebra`.
 
-  ## Inspect representation
-
-  There are typically three choices of inspect representation. In order
-  to understand them, let's imagine we have the following `User` struct:
-
-      defmodule User do
-        defstruct [:id, :name, :address]
-      end
-
-  Our choices are:
-
-    1. Print the struct using Elixir's struct syntax, for example:
-       `%User{address: "Earth", id: 13, name: "Jane"}`. This is the
-       default representation and best choice if all struct fields
-       are public.
-
-    2. Print using the `#User<...>` notation, for example: `#User<id: 13, name: "Jane", ...>`.
-       This notation does not emit valid Elixir code and is typically
-       used when the struct has private fields (for example, you may want
-       to hide the field `:address` to redact person identifiable information).
-
-    3. Print the struct using the expression syntax, for example:
-       `User.new(13, "Jane", "Earth")`. This assumes there is a `User.new/3`
-       function. This option is mostly used as an alternative to option 2
-       for representing custom data structures, such as `MapSet`, `Date.Range`,
-       and others.
-
-  You can implement the Inspect protocol for your own structs while
-  adhering to the conventions above. Option 1 is the default representation
-  and you can quickly achieve option 2 by deriving the `Inspect` protocol.
-  For option 3, you need your custom implementation.
-
-  ## Deriving
-
-  The `Inspect` protocol can be derived to customize the order of fields
-  (the default is alphabetical) and hide certain fields from structs,
-  so they don't show up in logs, inspects and similar. The latter is
-  especially useful for fields containing private information.
-
-  The supported options are:
-
-    * `:only` - only include the given fields when inspecting.
-
-    * `:except` - remove the given fields when inspecting.
-
-    * `:optional` - (since v1.14.0) do not include a field if it
-      matches its default value. This can be used to simplify the
-      struct representation at the cost of hiding information.
-
-  Whenever `:only` or `:except` are used to restrict fields,
-  the struct will be printed using the `#User<...>` notation,
-  as the struct can no longer be copy and pasted as valid Elixir
-  code. Let's see an example:
-
-      defmodule User do
-        @derive {Inspect, only: [:id, :name]}
-        defstruct [:id, :name, :address]
-      end
-
-      inspect(%User{id: 1, name: "Jane", address: "Earth"})
-      #=> #User<id: 1, name: "Jane", ...>
-
-  If you use only the `:optional` option, the struct will still be
-  printed as `%User{...}`.
-
-  ## Custom implementation
-
-  You can also define your custom protocol implementation by
-  defining the `inspect/2` function. The 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`.
+  ## 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(map_set, opts) do
-          concat(["MapSet.new(", Inspect.List.inspect(MapSet.to_list(map_set), opts), ")"])
+        def inspect(dict, opts) do
+          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.new("`,
-  the document returned by `Inspect.Algebra.to_doc/2`, and the final
-  string `")"`. Therefore, the MapSet with the numbers 1, 2, and 3
-  will be printed as:
+  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 `">"`.
 
-      iex> MapSet.new([1, 2, 3], fn x -> x * 2 end)
-      MapSet.new([2, 4, 6])
+  Since regular strings are valid entities in an algebra document,
+  an implementation of inspect may simply return a string,
+  although that will devoid it of any pretty-printing.
 
-  In other words, `MapSet`'s inspect representation returns an expression
-  that, when evaluated, builds the `MapSet` itself.
-
-  ### Error handling
+  ## Error handling
 
   In case there is an error while your structure is being inspected,
   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{})
+      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
 
@@ -146,12 +62,37 @@ defimpl Inspect, for: Atom do
   require Macro
 
   def inspect(atom, opts) do
-    color(Macro.inspect_atom(:literal, 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(atom) when is_nil(atom) or is_boolean(atom) do
+    Atom.to_string(atom)
+  end
+
+  def inspect(atom) when is_atom(atom) do
+    binary = Atom.to_string(atom)
+
+    case Macro.classify_identifier(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, :not_callable] ->
+        ":" <> binary
+      :other ->
+        {escaped, _} = Inspect.BitString.escape(binary, ?")
+        IO.iodata_to_binary [?:, ?", escaped, ?"]
+    end
+  end
 end
 
 defimpl Inspect, for: BitString do
@@ -159,13 +100,12 @@ defimpl Inspect, for: BitString 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
+       (bins == :as_strings or (bins == :infer and String.printable?(term, printable_limit))) do
       inspected =
-        case Identifier.escape(term, ?", printable_limit) do
+        case escape(term, ?", printable_limit) do
           {escaped, ""} -> [?", escaped, ?"]
           {escaped, _} -> [?", escaped, ?", " <> ..."]
         end
-
       color(IO.iodata_to_binary(inspected), :string, opts)
     else
       inspect_bitstring(term, opts)
@@ -176,6 +116,98 @@ defimpl Inspect, for: BitString do
     inspect_bitstring(term, opts)
   end
 
+  ## Escaping
+
+  @doc false
+  def escape(other, char) do
+    escape(other, char, :infinity, [])
+  end
+
+  @doc false
+  def escape(other, char, count) do
+    escape(other, char, count, [])
+  end
+
+  defp escape(<<_, _::binary>> = binary, _char, 0, acc) do
+    {acc, binary}
+  end
+  defp escape(<<char, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | [?\\, char]])
+  end
+  defp escape(<<?#, ?{, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\\#{'])
+  end
+  defp escape(<<?\a, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\a'])
+  end
+  defp escape(<<?\b, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\b'])
+  end
+  defp escape(<<?\d, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\d'])
+  end
+  defp escape(<<?\e, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\e'])
+  end
+  defp escape(<<?\f, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\f'])
+  end
+  defp escape(<<?\n, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\n'])
+  end
+  defp escape(<<?\r, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\r'])
+  end
+  defp escape(<<?\\, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\\\'])
+  end
+  defp escape(<<?\t, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\t'])
+  end
+  defp escape(<<?\v, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | '\\v'])
+  end
+  defp escape(<<h::utf8, t::binary>>, char, count, 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, decrement(count), [acc | <<h::utf8>>])
+  end
+  defp escape(<<h, t::binary>>, char, count, acc) do
+    escape(t, char, decrement(count), [acc | escape_char(h)])
+  end
+  defp escape(<<>>, _char, _count, acc) do
+    {acc, <<>>}
+  end
+
+  @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
@@ -183,8 +215,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
@@ -200,21 +231,19 @@ 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
     size = bit_size(bitstring)
     <<h::size(size)>> = bitstring
-    concat(Inspect.Integer.inspect(h, opts), "::size(" <> Integer.to_string(size) <> ")")
+    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
@@ -222,28 +251,19 @@ defimpl Inspect, for: List do
     color("[]", :list, opts)
   end
 
-  # TODO: Remove :char_list and :as_char_lists handling on v2.0
+  # TODO: Remove :char_list and :as_char_lists handling in 2.0
   def inspect(term, opts) do
-    %Inspect.Opts{
-      charlists: lists,
-      char_lists: lists_deprecated,
-      printable_limit: printable_limit
-    } = opts
-
+    %Inspect.Opts{charlists: lists, char_lists: lists_deprecated, printable_limit: printable_limit} = opts
     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"
-            )
-
+            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")
+            IO.warn "the :char_lists inspect option is deprecated, use :charlists instead"
             lists_deprecated
         end
       else
@@ -255,27 +275,24 @@ defimpl Inspect, for: List do
     close = color("]", :list, opts)
 
     cond do
-      lists == :as_charlists or (lists == :infer and List.ascii_printable?(term, printable_limit)) ->
+      lists == :as_charlists or (lists == :infer and printable?(term, printable_limit)) ->
         inspected =
-          case Identifier.escape(IO.chardata_to_string(term), ?', printable_limit) do
+          case Inspect.BitString.escape(IO.chardata_to_string(term), ?', printable_limit) do
             {escaped, ""} -> [?', escaped, ?']
             {escaped, _} -> [?', escaped, ?', " ++ ..."]
           end
-
-        color(IO.iodata_to_binary(inspected), :charlist, opts)
-
+        IO.iodata_to_binary inspected
       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(Macro.inspect_atom(: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
@@ -286,8 +303,38 @@ defimpl Inspect, for: List do
     end
   end
 
-  def keyword?([]), do: true
+  def keyword?([]),     do: true
   def keyword?(_other), do: false
+
+  @doc false
+  def printable?(list), do: printable?(list, :infinity)
+
+  @doc false
+  def printable?(_, 0), do: true
+  def printable?([char | rest], counter) when char in 32..126, do: printable?(rest, decrement(counter))
+  def printable?([?\n | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\r | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\t | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\v | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\b | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\f | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\e | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([?\a | rest], counter), do: printable?(rest, decrement(counter))
+  def printable?([], _counter), do: true
+  def printable?(_, _counter), do: false
+
+  @compile {:inline, decrement: 1}
+  defp decrement(:infinity), do: :infinity
+  defp decrement(counter),   do: counter - 1
+
+  ## 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
@@ -295,45 +342,37 @@ 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
-    list =
-      if Keyword.get(opts.custom_options, :sort_maps) do
-        map |> Map.to_list() |> :lists.sort()
-      else
-        Map.to_list(map)
-      end
-
-    fun =
-      if Inspect.List.keyword?(list) do
-        &Inspect.List.keyword/2
-      else
-        sep = color(" => ", :map, opts)
-        &to_assoc(&1, &2, sep)
-      end
-
-    map_container_doc(list, "", opts, fun)
+    nest inspect(map, "", opts), 1
   end
 
-  def inspect(map, name, infos, opts) do
-    fun = fn %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts) end
-    map_container_doc(infos, name, opts, fun)
-  end
-
-  defp to_assoc({key, value}, opts, sep) do
-    concat(concat(to_doc(key, opts), sep), to_doc(value, opts))
-  end
-
-  defp map_container_doc(list, name, opts, fun) do
+  def inspect(map, name, opts) do
+    map = :maps.to_list(map)
     open = color("%" <> name <> "{", :map, opts)
     sep = color(",", :map, opts)
     close = color("}", :map, opts)
-    container_doc(open, list, close, opts, fun, separator: sep, break: :strict)
+    surround_many(open, map, close, opts, traverse_fun(map, opts), sep)
+  end
+
+  defp traverse_fun(list, opts) do
+    if Inspect.List.keyword?(list) do
+      &Inspect.List.keyword/2
+    else
+      sep = color(" => ", :map, opts)
+      &to_map(&1, &2, sep)
+    end
+  end
+
+  defp to_map({key, value}, opts, sep) do
+    concat(
+      concat(to_doc(key, opts), sep),
+      to_doc(value, opts)
+    )
   end
 end
 
@@ -345,112 +384,137 @@ 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
 
 defimpl Inspect, for: Float do
-  def inspect(float, opts) do
-    abs = abs(float)
-
-    formatted =
-      if abs >= 1.0 and abs < 1.0e16 and trunc(float) == float do
-        [Integer.to_string(trunc(float)), ?., ?0]
-      else
-        :io_lib_format.fwrite_g(float)
-      end
-
-    color(IO.iodata_to_binary(formatted), :number, opts)
+  def inspect(term, opts) do
+    inspected = IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
+    color(inspected, :number, opts)
   end
 end
 
 defimpl Inspect, for: Regex do
-  def inspect(regex = %{opts: regex_opts}, opts) when is_list(regex_opts) do
-    concat([
-      "Regex.compile!(",
-      Inspect.BitString.inspect(regex.source, opts),
-      ", ",
-      Inspect.List.inspect(regex_opts, opts),
-      ")"
-    ])
-  end
-
   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::binary>>, 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::binary>>, buf, term),
+    do: escape(rest, [buf | '\\n'], term)
+
+  defp escape(<<?\r, rest::binary>>, buf, term),
+    do: escape(rest, [buf | '\\r'], term)
+
+  defp escape(<<?\t, rest::binary>>, buf, term),
+    do: escape(rest, [buf | '\\t'], term)
+
+  defp escape(<<?\v, rest::binary>>, buf, term),
+    do: escape(rest, [buf | '\\v'], term)
+
+  defp escape(<<?\f, rest::binary>>, buf, term),
+    do: escape(rest, [buf | '\\f'], term)
+
+  defp escape(<<?\a, rest::binary>>, 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
-      not is_atom(mod) ->
-        "#Function<#{uniq(fun_info)}/#{fun_info[:arity]}>"
-
-      fun_info[:type] == :external and fun_info[:env] == [] ->
-        inspected_as_atom = Macro.inspect_atom(:literal, mod)
-        inspected_as_function = Macro.inspect_atom(:remote_call, 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)}.#{escape_name(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
 
+  def escape_name(atom) when is_atom(atom) do
+    string = Atom.to_string(atom)
+
+    case Macro.classify_identifier(atom) do
+      :callable ->
+        string
+      type when type in [:not_callable, :alias] ->
+        "\"" <> string <> "\""
+      :other ->
+        {escaped, _} = Inspect.BitString.escape(string, ?")
+        IO.iodata_to_binary [?", escaped, ?"]
+    end
+  end
+
+  # Example of this format: -NAME/ARITY-fun-COUNT-
+  def extract_anonymous_fun_parent(atom) when is_atom(atom) do
+    extract_anonymous_fun_parent(Atom.to_string(atom))
+  end
+
+  def extract_anonymous_fun_parent("-" <> rest) do
+    [trailing | reversed] =
+      rest
+      |> String.split("/")
+      |> Enum.reverse()
+
+    case String.split(trailing, "-") do
+      [arity, _inner, _count, ""] ->
+        {reversed |> Enum.reverse |> Enum.join("/") |> String.to_atom(), arity}
+      _other ->
+        :error
+    end
+  end
+
+  def extract_anonymous_fun_parent(other) when is_binary(other), do: :error
+
   defp default_inspect(mod, fun_info) do
-    inspected_as_atom = Macro.inspect_atom(:literal, 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
@@ -458,47 +522,17 @@ defimpl Inspect, for: Function do
   end
 
   defp extract_name(name) do
-    case Identifier.extract_anonymous_fun_parent(name) do
+    case extract_anonymous_fun_parent(name) do
       {name, arity} ->
-        "." <> Macro.inspect_atom(:remote_call, name) <> "/" <> arity
-
+        "." <> escape_name(name) <> "/" <> arity
       :error ->
-        "." <> Macro.inspect_atom(:remote_call, name)
+        "." <> escape_name(name)
     end
   end
 
   defp uniq(fun_info) do
-    Integer.to_string(fun_info[:new_index]) <> "." <> Integer.to_string(fun_info[:uniq])
-  end
-end
-
-defimpl Inspect, for: Inspect.Error do
-  @impl true
-  def inspect(%{stacktrace: stacktrace} = inspect_error, _opts) do
-    message = Exception.message(inspect_error)
-    format_output(message, stacktrace)
-  end
-
-  defp format_output(message, [_ | _] = stacktrace) do
-    stacktrace = Exception.format_stacktrace(stacktrace)
-
-    """
-    #Inspect.Error<
-    #{Inspect.Error.pad(message, 2)}
-
-      Stacktrace:
-
-    #{stacktrace}
-    >\
-    """
-  end
-
-  defp format_output(message, []) do
-    """
-    #Inspect.Error<
-      #{Inspect.Error.pad(message, 2)}
-    >\
-    """
+    Integer.to_string(fun_info[:new_index]) <> "." <>
+      Integer.to_string(fun_info[:uniq])
   end
 end
 
@@ -522,123 +556,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, [])
-    optional = Keyword.get(options, :optional, [])
-
-    :ok = validate_option(:only, only, fields, module)
-    :ok = validate_option(:except, except, fields, module)
-    :ok = validate_option(:optional, optional, fields, module)
-
-    inspect_module =
-      if fields == only and except == [] do
-        Inspect.Map
-      else
-        Inspect.Any
-      end
-
-    filtered_fields =
-      fields
-      |> Enum.reject(&(&1 in except))
-      |> Enum.filter(&(&1 in only))
-
-    optional? =
-      if optional == [] do
-        false
-      else
-        optional_map = for field <- optional, into: %{}, do: {field, Map.fetch!(struct, field)}
-
-        quote do
-          case unquote(Macro.escape(optional_map)) do
-            %{^var!(field) => var!(default)} ->
-              var!(default) == Map.get(var!(struct), var!(field))
-
-            %{} ->
-              false
-          end
-        end
-      end
-
-    quote do
-      defimpl Inspect, for: unquote(module) do
-        def inspect(var!(struct), var!(opts)) do
-          var!(infos) =
-            for %{field: var!(field)} = var!(info) <- unquote(module).__info__(:struct),
-                var!(field) in unquote(filtered_fields) and not unquote(optional?),
-                do: var!(info)
-
-          var!(name) = Macro.inspect_atom(:literal, unquote(module))
-          unquote(inspect_module).inspect(var!(struct), var!(name), var!(infos), var!(opts))
-        end
-      end
-    end
-  end
-
-  defp validate_option(option, option_list, fields, module) do
-    case option_list -- fields do
-      [] ->
-        :ok
-
-      unknown_fields ->
-        raise ArgumentError,
-              "unknown fields #{Kernel.inspect(unknown_fields)} in #{Kernel.inspect(option)} " <>
-                "when deriving the Inspect protocol for #{Kernel.inspect(module)}"
-    end
-  end
-
-  def inspect(%module{} = struct, opts) do
+  def inspect(%{__struct__: struct} = map, opts) do
     try do
-      {module.__struct__(), module.__info__(:struct)}
+      struct.__struct__
     rescue
-      _ -> Inspect.Map.inspect(struct, opts)
+      _ -> Inspect.Map.inspect(map, opts)
     else
-      {dunder, fields} ->
-        if Map.keys(dunder) == Map.keys(struct) do
-          infos =
-            for %{field: field} = info <- fields,
-                field not in [:__struct__, :__exception__],
-                do: info
-
-          Inspect.Map.inspect(struct, Macro.inspect_atom(:literal, module), infos, opts)
+      dunder ->
+        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, infos, opts) do
-    open = color("#" <> name <> "<", :map, opts)
-    sep = color(",", :map, opts)
-    close = color(">", :map, opts)
-
-    fun = fn
-      %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts)
-      :..., _opts -> "..."
-    end
-
-    container_doc(open, infos ++ [:...], close, opts, fun, 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`:
-
-    * `Kernel.abs/1`
-    * `Kernel.div/2`
-    * `Kernel.max/2`
-    * `Kernel.min/2`
-    * `Kernel.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,55 +55,14 @@ defmodule Integer do
       true
 
   """
-  defguard is_even(integer) when is_integer(integer) and (integer &&& 1) == 0
-
-  @doc """
-  Computes `base` raised to power of `exponent`.
-
-  Both `base` and `exponent` must be integers.
-  The exponent must be zero or positive.
-
-  See `Float.pow/2` for exponentiation of negative
-  exponents as well as floats.
-
-  ## Examples
-
-      iex> Integer.pow(2, 0)
-      1
-      iex> Integer.pow(2, 1)
-      2
-      iex> Integer.pow(2, 10)
-      1024
-      iex> Integer.pow(2, 11)
-      2048
-      iex> Integer.pow(2, 64)
-      0x10000000000000000
-
-      iex> Integer.pow(3, 4)
-      81
-      iex> Integer.pow(4, 3)
-      64
-
-      iex> Integer.pow(-2, 3)
-      -8
-      iex> Integer.pow(-2, 4)
-      16
-
-      iex> Integer.pow(2, -2)
-      ** (ArithmeticError) bad argument in arithmetic expression
-
-  """
-  @doc since: "1.12.0"
-  @spec pow(integer, non_neg_integer) :: integer
-  def pow(base, exponent) when is_integer(base) and is_integer(exponent) do
-    if exponent < 0, do: :erlang.error(:badarith, [base, exponent])
-    base ** exponent
+  defmacro is_even(integer) do
+    quote do: (unquote(integer) &&& 1) == 0
   end
 
   @doc """
   Computes the modulo remainder of an integer division.
 
-  This function performs a [floored division](`floor_div/2`), which means that
+  `Integer.mod/2` uses floored division, which means that
   the result will always have the sign of the `divisor`.
 
   Raises an `ArithmeticError` exception if one of the arguments is not an
@@ -124,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
@@ -142,8 +92,8 @@ defmodule Integer do
   Raises an `ArithmeticError` exception if one of the arguments is not an
   integer, or when the `divisor` is `0`.
 
-  This function performs a *floored* integer division, which means that
-  the result will always be rounded towards negative infinity.
+  `Integer.floor_div/2` performs *floored* integer division. This means that
+  the result is always rounded towards negative infinity.
 
   If you want to perform truncated integer division (rounding towards zero),
   use `Kernel.div/2` instead.
@@ -158,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)
@@ -192,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])
 
@@ -201,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
 
@@ -215,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)
 
@@ -239,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
@@ -269,55 +232,50 @@ defmodule Integer do
       ** (ArgumentError) invalid base 38
 
   """
-  @spec parse(binary, 2..36) :: {integer, remainder_of_binary :: binary} | :error
+  @spec parse(binary, 2..36) :: {integer, binary} | :error
   def parse(binary, base \\ 10)
 
-  def parse(_binary, base) when base not in 2..36 do
-    raise ArgumentError, "invalid base #{inspect(base)}"
+  def parse(_binary, base) when not base in 2..36 do
+    raise ArgumentError, "invalid base #{inspect base}"
   end
 
-  def parse(binary, base) when is_binary(binary) do
+  def parse(binary, base) do
     case count_digits(binary, base) do
       0 ->
         :error
-
       count ->
         {digits, rem} = :erlang.split_binary(binary, count)
         {:erlang.binary_to_integer(digits, base), rem}
     end
   end
 
-  defp count_digits(<<sign, rest::bits>>, base) when sign in '+-' do
+  defp count_digits(<<sign, rest::binary>>, base) when sign in '+-' do
     case count_digits_nosign(rest, base, 1) do
       1 -> 0
       count -> count
     end
   end
 
-  defp count_digits(<<rest::bits>>, base) do
+  defp count_digits(<<rest::binary>>, base) do
     count_digits_nosign(rest, base, 0)
   end
 
   digits = [{?0..?9, -?0}, {?A..?Z, 10 - ?A}, {?a..?z, 10 - ?a}]
 
-  for {chars, diff} <- digits,
-      char <- chars do
+  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
+    defp count_digits_nosign(<<unquote(char), rest::binary>>, base, count)
+        when base > unquote(digit) do
       count_digits_nosign(rest, base, count + 1)
     end
   end
 
-  defp count_digits_nosign(<<_::bits>>, _, count), do: count
+  defp count_digits_nosign(<<_::binary>>, _, count), do: count
 
   @doc """
   Returns a binary which corresponds to the text representation
-  of `integer` in the given `base`.
-
-  `base` can be an integer between 2 and 36. If no `base` is given,
-  it defaults to `10`.
+  of `integer`.
 
   Inlined by the compiler.
 
@@ -335,27 +293,39 @@ defmodule Integer do
       iex> Integer.to_string(0123)
       "123"
 
+  """
+  @spec to_string(integer) :: String.t
+  def to_string(integer) do
+    :erlang.integer_to_binary(integer)
+  end
+
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `integer` in the given `base`.
+
+  `base` can be an integer between 2 and 36.
+
+  Inlined by the compiler.
+
+  ## Examples
+
       iex> Integer.to_string(100, 16)
       "64"
 
       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()
-  def to_string(integer, base \\ 10) do
+  @spec to_string(integer, 2..36) :: String.t
+  def to_string(integer, base) do
     :erlang.integer_to_binary(integer, base)
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation
-  of `integer` in the given `base`.
-
-  `base` can be an integer between 2 and 36. If no `base` is given,
-  it defaults to `10`.
+  Returns a charlist which corresponds to the text representation of the given `integer`.
 
   Inlined by the compiler.
 
@@ -373,18 +343,33 @@ defmodule Integer do
       iex> Integer.to_charlist(0123)
       '123'
 
+  """
+  @spec to_charlist(integer) :: charlist
+  def to_charlist(integer) do
+    :erlang.integer_to_list(integer)
+  end
+
+  @doc """
+  Returns a charlist which corresponds to the text representation of `integer` in the given `base`.
+
+  `base` can be an integer between 2 and 36.
+
+  Inlined by the compiler.
+
+  ## Examples
+
       iex> Integer.to_charlist(100, 16)
       '64'
 
       iex> Integer.to_charlist(-100, 16)
       '-64'
 
-      iex> Integer.to_charlist(882_681_651, 36)
+      iex> Integer.to_charlist(882681651, 36)
       'ELIXIR'
 
   """
   @spec to_charlist(integer, 2..36) :: charlist
-  def to_charlist(integer, base \\ 10) do
+  def to_charlist(integer, base) do
     :erlang.integer_to_list(integer, base)
   end
 
@@ -417,8 +402,8 @@ defmodule Integer do
       0
 
   """
-  @doc since: "1.5.0"
-  @spec gcd(integer, integer) :: non_neg_integer
+  @spec gcd(0, 0) :: 0
+  @spec gcd(integer, integer) :: pos_integer
   def gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
     gcd_positive(abs(integer1), abs(integer2))
   end
@@ -427,63 +412,15 @@ defmodule Integer do
   defp gcd_positive(integer1, 0), do: integer1
   defp gcd_positive(integer1, integer2), do: gcd_positive(integer2, rem(integer1, integer2))
 
-  @doc """
-  Returns the extended greatest common divisor of the two given integers.
-
-  This function uses the extended Euclidean algorithm to return a three-element tuple with the `gcd`
-  and the coefficients `m` and `n` of Bézout's identity such that:
-
-      gcd(a, b) = m*a + n*b
-
-  By convention, `extended_gcd(0, 0)` returns `{0, 0, 0}`.
-
-  ## Examples
-
-      iex> Integer.extended_gcd(240, 46)
-      {2, -9, 47}
-      iex> Integer.extended_gcd(46, 240)
-      {2, 47, -9}
-      iex> Integer.extended_gcd(-46, 240)
-      {2, -47, -9}
-      iex> Integer.extended_gcd(-46, -240)
-      {2, -47, 9}
-
-      iex> Integer.extended_gcd(14, 21)
-      {7, -1, 1}
-
-      iex> Integer.extended_gcd(10, 0)
-      {10, 1, 0}
-      iex> Integer.extended_gcd(0, 10)
-      {10, 0, 1}
-      iex> Integer.extended_gcd(0, 0)
-      {0, 0, 0}
-
-  """
-  @doc since: "1.12.0"
-  @spec extended_gcd(integer, integer) :: {non_neg_integer, integer, integer}
-  def extended_gcd(0, 0), do: {0, 0, 0}
-  def extended_gcd(0, b), do: {b, 0, 1}
-  def extended_gcd(a, 0), do: {a, 1, 0}
-
-  def extended_gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
-    extended_gcd(integer2, integer1, 0, 1, 1, 0)
-  end
-
-  defp extended_gcd(r1, r0, s1, s0, t1, t0) do
-    div = div(r0, r1)
-
-    case r0 - div * r1 do
-      0 when r1 > 0 -> {r1, s1, t1}
-      0 when r1 < 0 -> {-r1, -s1, -t1}
-      r2 -> extended_gcd(r2, r1, s0 - div * s1, s1, t0 - div * t1, t1)
-    end
-  end
-
+  # TODO: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
   @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)
 
+  # TODO: Remove by 2.0
+  # (hard-deprecated in elixir_dispatch)
   @doc false
-  @deprecated "Use Integer.to_charlist/2 instead"
+  @spec to_char_list(integer, 2..36) :: charlist
   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,112 +27,29 @@ 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 within the `0..255` range)
-  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 within the `0..255` range, while Unicode code points
-  (`t:char/0`) are integers within the `0..0x10FFFF` range. 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:
-
-      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_device(term) when is_atom(term) or is_pid(term)
-  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`.
 
-  The `device` is iterated by the given number of characters, line by line if
-  `:line` is given, or until `:eof`.
+  The `device` is iterated by the given number of characters or line by line if
+  `:line` is given.
+  Alternatively, if `:all` is given, then whole `device` is returned.
 
   It returns:
 
@@ -141,24 +61,14 @@ defmodule IO do
       for instance, `{:error, :estale}` if reading from an
       NFS volume
 
+  If `:all` is given, `:eof` is never returned, but an
+  empty string in case the device has reached EOF.
   """
-  @spec read(device, :eof | :line | non_neg_integer) :: chardata | nodata
+  @spec read(device, :all | :line | non_neg_integer) :: chardata | nodata
   def read(device \\ :stdio, line_or_chars)
 
-  # TODO: Deprecate me on v1.17
   def read(device, :all) do
-    with :eof <- read(device, :eof) do
-      with [_ | _] = opts <- :io.getopts(device),
-           false <- Keyword.get(opts, :binary, true) do
-        ''
-      else
-        _ -> ""
-      end
-    end
-  end
-
-  def read(device, :eof) do
-    getn(device, '', :eof)
+    do_read_all(map_dev(device), "")
   end
 
   def read(device, :line) do
@@ -169,20 +79,20 @@ defmodule IO do
     :io.get_chars(map_dev(device), '', count)
   end
 
+  defp do_read_all(mapped_dev, acc) do
+    case :io.get_line(mapped_dev, "") do
+      line when is_binary(line) -> do_read_all(mapped_dev, acc <> line)
+      :eof -> acc
+      other -> other
+    end
+  end
+
   @doc """
   Reads from the IO `device`. The operation is Unicode unsafe.
 
-  The `device` is iterated as specified by the `line_or_chars` argument:
-
-    * if `line_or_chars` is an integer, it represents a number of bytes. The device is
-      iterated by that number of bytes.
-
-    * if `line_or_chars` is `:line`, the device is iterated line by line.
-
-    * if `line_or_chars` is `:eof`, the device is iterated until `:eof`. `line_or_chars`
-      can only be `:eof` since Elixir 1.13.0. `:eof` replaces the deprecated `:all`,
-      with the difference that `:all` returns `""` on end of file, while `:eof` returns
-      `:eof` itself.
+  The `device` is iterated by the given number of bytes or line by line if
+  `:line` is given.
+  Alternatively, if `:all` is given, then whole `device` is returned.
 
   It returns:
 
@@ -194,19 +104,17 @@ defmodule IO do
       for instance, `{:error, :estale}` if reading from an
       NFS volume
 
+  If `:all` is given, `:eof` is never returned, but an
+  empty string in case the device has reached EOF.
+
   Note: do not use this function on IO devices in Unicode mode
   as it will return the wrong result.
   """
-  @spec binread(device, :eof | :line | non_neg_integer) :: iodata | nodata
+  @spec binread(device, :all | :line | non_neg_integer) :: iodata | nodata
   def binread(device \\ :stdio, line_or_chars)
 
-  # TODO: Deprecate me on v1.17
   def binread(device, :all) do
-    with :eof <- binread(device, :eof), do: ""
-  end
-
-  def binread(device, :eof) do
-    binread_eof(map_dev(device), "")
+    do_binread_all(map_dev(device), "")
   end
 
   def binread(device, :line) do
@@ -224,157 +132,82 @@ defmodule IO do
   end
 
   @read_all_size 4096
-  defp binread_eof(mapped_dev, acc) do
+  defp do_binread_all(mapped_dev, acc) do
     case :file.read(mapped_dev, @read_all_size) do
-      {:ok, data} -> binread_eof(mapped_dev, acc <> data)
-      :eof -> if acc == "", do: :eof, else: acc
+      {:ok, data} -> do_binread_all(mapped_dev, acc <> data)
+      :eof -> acc
       other -> other
     end
   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
-  def puts(device \\ :stdio, item) when is_device(device) do
-    :io.put_chars(map_dev(device), [to_chardata(item), ?\n])
+  @spec puts(device, chardata | String.Chars.t) :: :ok
+  def puts(device \\ :stdio, item) do
+    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
   end
 
   @doc """
-  Writes a `message` to stderr, along with the given `stacktrace_info`.
-
-  The `stacktrace_info` must be one of:
-
-    * a `__STACKTRACE__`, where all entries in the stacktrace will be
-      included in the error message
-
-    * a `Macro.Env` structure (since v1.14.0), where a single stacktrace
-      entry from the compilation environment will be used
-
-    * a keyword list with at least the `:file` option representing
-      a single stacktrace entry (since v1.14.0). The `:line`, `:module`,
-      `:function` options are also supported
+  Writes a `message` to stderr, along with the given `stacktrace`.
 
   This function also notifies the compiler a warning was printed
   (in case --warnings-as-errors was enabled). It returns `:ok`
   if it succeeds.
 
+  An empty list can be passed to avoid stacktrace printing.
+
   ## 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() | keyword() | Macro.Env.t()) ::
-          :ok
-  def warn(message, stacktrace_info)
-
+  @spec warn(chardata | String.Chars.t, Exception.stacktrace) :: :ok
   def warn(message, []) do
-    message = [to_chardata(message), ?\n]
-    :elixir_errors.log_and_print_warning(0, nil, message, message)
+    :elixir_errors.warn([to_chardata(message), ?\n])
   end
-
-  def warn(message, %Macro.Env{} = env) do
-    warn(message, Macro.Env.stacktrace(env))
-  end
-
-  def warn(message, [{_, _} | _] = keyword) do
-    if file = keyword[:file] do
-      warn(
-        message,
-        %{
-          __ENV__
-          | module: keyword[:module],
-            function: keyword[:function],
-            line: keyword[:line],
-            file: file
-        }
-      )
-    else
-      warn(message, [])
-    end
-  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.log_and_print_warning(
-      line || 0,
-      file && List.to_string(file),
-      message,
-      [message, ?\n, "  ", formatted_trace, ?\n]
-    )
-  end
-
-  @doc false
-  def warn_once(key, message, stacktrace_drop_levels) do
-    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
-    stacktrace = Enum.drop(stacktrace, stacktrace_drop_levels)
-
-    if :elixir_config.warn(key, stacktrace) do
-      warn(message, stacktrace)
-    else
-      :ok
-    end
+  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 """
@@ -382,19 +215,14 @@ defmodule IO do
 
   It returns `:ok` if it succeeds.
 
-  Do not call this function at the tail of another function. Due to tail
-  call optimization, a stacktrace entry would not be added and the
-  stacktrace would be incorrectly trimmed. Therefore make sure at least
-  one expression (or an atom such as `:ok`) follows the `IO.warn/1` call.
-
   ## 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))
@@ -420,7 +248,7 @@ defmodule IO do
 
   ## Examples
 
-      IO.inspect(<<0, 1, 2>>, width: 40)
+      IO.inspect <<0, 1, 2>>, width: 40
 
   Prints:
 
@@ -428,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:
 
@@ -440,7 +268,7 @@ defmodule IO do
       |> IO.inspect(label: "before")
       |> Enum.map(&(&1 * 2))
       |> IO.inspect(label: "after")
-      |> Enum.sum()
+      |> Enum.sum
 
   Prints:
 
@@ -450,7 +278,7 @@ defmodule IO do
   """
   @spec inspect(item, keyword) :: item when item: var
   def inspect(item, opts \\ []) do
-    inspect(:stdio, item, opts)
+    inspect :stdio, item, opts
   end
 
   @doc """
@@ -459,12 +287,11 @@ defmodule IO do
   See `inspect/2` for a full list of options.
   """
   @spec inspect(device, item, keyword) :: item when item: var
-  def inspect(device, item, opts) when is_device(device) and is_list(opts) do
-    label = if label = opts[:label], do: [to_chardata(label), ": "], else: []
-    opts = Inspect.Opts.new(opts)
-    doc = Inspect.Algebra.group(Inspect.Algebra.to_doc(item, opts))
-    chardata = Inspect.Algebra.format(doc, opts.width)
-    puts(device, [label, chardata])
+  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)
+    chardata = Inspect.Algebra.format(Inspect.Algebra.to_doc(item, opts), opts.width)
+    puts device, [label, chardata]
     item
   end
 
@@ -472,21 +299,15 @@ 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(
-          device | chardata | String.Chars.t(),
-          pos_integer | :eof | chardata | String.Chars.t()
-        ) ::
-          chardata | nodata
-  def getn(prompt, count \\ 1)
 
-  def getn(prompt, :eof) do
-    getn(:stdio, prompt, :eof)
-  end
+  """
+  @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
     getn(:stdio, prompt, count)
@@ -500,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:
@@ -514,27 +335,11 @@ defmodule IO do
       NFS volume
 
   """
-  @spec getn(device, chardata | String.Chars.t(), pos_integer | :eof) :: chardata | nodata
-  def getn(device, prompt, :eof) do
-    getn_eof(map_dev(device), to_chardata(prompt), [])
-  end
-
+  @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
 
-  defp getn_eof(device, prompt, acc) do
-    case :io.get_line(device, prompt) do
-      line when is_binary(line) or is_list(line) -> getn_eof(device, '', [line | acc])
-      :eof -> wrap_eof(:lists.reverse(acc))
-      other -> other
-    end
-  end
-
-  defp wrap_eof([h | _] = acc) when is_binary(h), do: IO.iodata_to_binary(acc)
-  defp wrap_eof([h | _] = acc) when is_list(h), do: :lists.flatten(acc)
-  defp wrap_eof([]), do: :eof
-
   @doc ~S"""
   Reads a line from the IO `device`.
 
@@ -553,25 +358,14 @@ 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
 
-  @doc """
-  Returns a line-based `IO.Stream` on `:stdio`.
-
-  This is equivalent to:
-
-      IO.stream(:stdio, :line)
-
-  """
-  @doc since: "1.12.0"
-  def stream, do: stream(:stdio, :line)
-
   @doc """
   Converts the IO `device` into an `IO.Stream`.
 
@@ -588,35 +382,21 @@ defmodule IO do
   Note that an IO stream has side effects and every time
   you go over the stream you may get different results.
 
-  `stream/0` has been introduced in Elixir v1.12.0,
-  while `stream/2` has been available since v1.0.0.
-
   ## Examples
 
   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()
-  def stream(device \\ :stdio, line_or_codepoints)
+  @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
     IO.Stream.__build__(map_dev(device), false, line_or_codepoints)
   end
 
-  @doc """
-  Returns a raw, line-based `IO.Stream` on `:stdio`. The operation is Unicode unsafe.
-
-  This is equivalent to:
-
-      IO.binstream(:stdio, :line)
-
-  """
-  @doc since: "1.12.0"
-  def binstream, do: binstream(:stdio, :line)
-
   @doc """
   Converts the IO `device` into an `IO.Stream`. The operation is Unicode unsafe.
 
@@ -625,7 +405,8 @@ defmodule IO do
   and write.
 
   The `device` is iterated by the given number of bytes or line by line if
-  `:line` is given. This reads from the IO device as a raw binary.
+  `:line` is given.
+  This reads from the IO device as a raw binary.
 
   Note that an IO stream has side effects and every time
   you go over the stream you may get different results.
@@ -633,21 +414,17 @@ defmodule IO do
   Finally, do not use this function on IO devices in Unicode
   mode as it will return the wrong result.
 
-  `binstream/0` has been introduced in Elixir v1.12.0,
-  while `binstream/2` has been available since v1.0.0.
   """
-  @spec binstream(device, :line | pos_integer) :: Enumerable.t()
-  def binstream(device \\ :stdio, line_or_bytes)
+  @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
     IO.Stream.__build__(map_dev(device), true, line_or_bytes)
   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.
@@ -664,9 +441,7 @@ defmodule IO do
       "string"
 
   """
-  @spec chardata_to_string(chardata) :: String.t()
-  def chardata_to_string(chardata)
-
+  @spec chardata_to_string(chardata) :: String.t | no_return
   def chardata_to_string(string) when is_binary(string) do
     string
   end
@@ -676,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.
 
-  Note 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.
 
@@ -705,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.
 
@@ -724,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
@@ -733,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
@@ -747,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
@@ -759,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

@@ -3,7 +3,6 @@ defmodule IO.ANSI.Sequence do
 
   defmacro defsequence(name, code, terminator \\ "m") do
     quote bind_quoted: [name: name, code: code, terminator: terminator] do
-      @spec unquote(name)() :: String.t()
       def unquote(name)() do
         "\e[#{unquote(code)}#{unquote(terminator)}"
       end
@@ -22,38 +21,12 @@ defmodule IO.ANSI do
   [ANSI escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)
   are characters embedded in text used to control formatting, color, and
   other output options on video text terminals.
-
-  ANSI escapes are typically enabled on all Unix terminals. They are also
-  available on Windows consoles from Windows 10, although it must be
-  explicitly enabled for the current user in the registry by running the
-  following command:
-
-      reg add HKCU\\Console /v VirtualTerminalLevel /t REG_DWORD /d 1
-
-  After running the command above, you must restart your current console.
-
-  ## Examples
-
-  Because the ANSI escape sequences are embedded in text, the normal usage of
-  these functions is to concatenate their output with text.
-
-      formatted_text = IO.ANSI.blue_background() <> "Example" <> IO.ANSI.reset()
-      IO.puts(formatted_text)
-
-  A higher level and more convenient API is also available via `IO.ANSI.format/1`,
-  where you use atoms to represent each ANSI escape sequence and by default
-  checks if ANSI is enabled:
-
-      IO.puts(IO.ANSI.format([:blue_background, "Example"]))
-
-  In case ANSI is disabled, the ANSI escape sequences are simply discarded.
   """
 
   import IO.ANSI.Sequence
 
   @type ansicode :: atom
-  @type ansilist ::
-          maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
+  @type ansilist :: maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
   @type ansidata :: ansilist | ansicode | binary
 
   @doc """
@@ -69,36 +42,8 @@ defmodule IO.ANSI do
     Application.get_env(:elixir, :ansi_enabled, false)
   end
 
-  @doc """
-  Syntax colors to be used by `Inspect`.
-
-  Those colors are used throughout Elixir's standard library,
-  such as `dbg/2` and `IEx`.
-
-  The colors can be changed by setting the `:ansi_syntax_colors`
-  in the `:elixir` application configuration. Configuration for
-  most built-in data types are supported: `:atom`, `:binary`,
-  `:boolean`, `:charlist`, `:list`, `:map`, `:nil`, `:number`,
-  `:string`, and `:tuple`. The default is:
-
-      [
-        atom: :cyan
-        boolean: :magenta,
-        charlist: :yellow,
-        nil: :magenta,
-        number: :yellow,
-        string: :green
-      ]
-
-  """
-  @doc since: "1.14.0"
-  @spec syntax_colors :: Keyword.t(ansidata)
-  def syntax_colors do
-    Application.fetch_env!(:elixir, :ansi_syntax_colors)
-  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"""
@@ -106,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"""
@@ -120,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"""
@@ -271,7 +189,7 @@ defmodule IO.ANSI do
   performed. If you don't want this behaviour, use `format_fragment/2`.
 
   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
@@ -280,9 +198,8 @@ defmodule IO.ANSI do
       [[[[[[], "Hello, "] | "\e[31m"] | "\e[1m"], "world!"] | "\e[0m"]
 
   """
-  @spec format(ansidata, boolean) :: IO.chardata()
-  def format(ansidata, emit? \\ enabled?()) when is_boolean(emit?) do
-    do_format(ansidata, [], [], emit?, :maybe)
+  def format(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
+    do_format(chardata, [], [], emit?, :maybe)
   end
 
   @doc ~S"""
@@ -292,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
@@ -301,9 +218,8 @@ defmodule IO.ANSI do
       [[[[[[] | "\e[1m"], 87], 111], 114], 100]
 
   """
-  @spec format_fragment(ansidata, boolean) :: IO.chardata()
-  def format_fragment(ansidata, emit? \\ enabled?()) when is_boolean(emit?) do
-    do_format(ansidata, [], [], emit?, false)
+  def format_fragment(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
+    do_format(chardata, [], [], emit?, false)
   end
 
   defp do_format([term | rest], rem, acc, emit?, append_reset) do
@@ -327,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

@@ -1,24 +1,20 @@
 defmodule IO.ANSI.Docs do
   @moduledoc false
 
-  @bullet_text_unicode "• "
-  @bullet_text_ascii "* "
   @bullets [?*, ?-, ?+]
   @spaces [" ", "\n", "\t"]
 
   @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)
@@ -26,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 """
@@ -48,267 +39,24 @@ defmodule IO.ANSI.Docs do
 
   See `default_options/0` for docs on the supported options.
   """
-  @spec print_headings([String.t()], keyword) :: :ok
-  def print_headings(headings, options \\ []) do
+  def print_heading(heading, options \\ []) do
+    IO.puts IO.ANSI.reset
     options = Keyword.merge(default_options(), options)
-    newline_after_block(options)
-    width = options[:width]
-
-    for heading <- headings do
-      padding = div(width + String.length(heading), 2)
-      heading = String.pad_leading(heading, padding)
-      heading = if options[:enabled], do: String.pad_trailing(heading, width), else: heading
-      write(:doc_title, heading, options)
-    end
-
-    newline_after_block(options)
+    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).
+  Prints the documentation body.
 
-  See `default_options/0` for docs on the supported options.
+  In addition to the printing string, takes a set of options
+  defined in `default_options/1`.
   """
-  @spec print_metadata(map, keyword) :: :ok
-  def print_metadata(metadata, options \\ []) when is_map(metadata) do
+  def print(doc, options \\ []) 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
-    metadata
-    |> Enum.sort()
-    |> Enum.reduce(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), ?\s, to_string(value)])
-
-      {:delegate_to, {m, f, a}}, _printed ->
-        label = metadata_label(:delegate_to, options)
-        IO.puts([label, ?\s, Exception.format_mfa(m, f, a)])
-
-      _metadata, printed ->
-        printed
-    end)
-  end
-
-  defp metadata_label(key, options) do
-    "#{color(:doc_metadata, options)}#{key}:#{maybe_reset(options)}"
-  end
-
-  @doc """
-  Prints the documentation body `doc` according to `format`.
-
-  It takes a set of `options` defined in `default_options/0`.
-  """
-  @spec print(term(), String.t(), keyword) :: :ok
-  def print(doc, format, options \\ [])
-
-  def print(doc, "text/markdown", options) when is_binary(doc) and is_list(options) do
-    print_markdown(doc, options)
-  end
-
-  def print(doc, "application/erlang+html", options) when is_list(options) do
-    print_erlang_html(doc, options)
-  end
-
-  def print(_doc, format, options) when is_binary(format) and is_list(options) do
-    IO.puts("\nUnknown documentation format #{inspect(format)}\n")
-  end
-
-  ## Erlang+html
-
-  def print_erlang_html(doc, options) do
-    options = Keyword.merge(default_options(), options)
-    IO.write(traverse_erlang_html(doc, "", options))
-  end
-
-  defp traverse_erlang_html(text, _indent, _options) when is_binary(text) do
-    text
-  end
-
-  defp traverse_erlang_html(nodes, indent, options) when is_list(nodes) do
-    for node <- nodes do
-      traverse_erlang_html(node, indent, options)
-    end
-  end
-
-  defp traverse_erlang_html({:div, [class: class] ++ _, entries}, indent, options) do
-    prefix = indent <> quote_prefix(options)
-
-    content =
-      entries
-      |> traverse_erlang_html(indent, options)
-      |> IO.iodata_to_binary()
-      |> String.trim_trailing()
-
-    [
-      prefix,
-      class |> to_string() |> String.upcase(),
-      "\n#{prefix}\n#{prefix}" | String.replace(content, "\n", "\n#{prefix}")
-    ]
-    |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:p, _, entries}, indent, options) do
-    [indent | handle_erlang_html_text(entries, indent, options)]
-  end
-
-  defp traverse_erlang_html({:h1, _, entries}, indent, options) do
-    entries |> traverse_erlang_html(indent, options) |> heading(1, options) |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:h2, _, entries}, indent, options) do
-    entries |> traverse_erlang_html(indent, options) |> heading(2, options) |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:h3, _, entries}, indent, options) do
-    entries |> traverse_erlang_html(indent, options) |> heading(3, options) |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:h4, _, entries}, indent, options) do
-    entries |> traverse_erlang_html(indent, options) |> heading(4, options) |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:h5, _, entries}, indent, options) do
-    entries |> traverse_erlang_html(indent, options) |> heading(5, options) |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:h6, _, entries}, indent, options) do
-    entries |> traverse_erlang_html(indent, options) |> heading(6, options) |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:br, _, []}, _indent, _options) do
-    []
-  end
-
-  defp traverse_erlang_html({:i, _, entries}, indent, options) do
-    inline_text("_", traverse_erlang_html(entries, indent, options), options)
-  end
-
-  defp traverse_erlang_html({:em, _, entries}, indent, options) do
-    inline_text("*", traverse_erlang_html(entries, indent, options), options)
-  end
-
-  defp traverse_erlang_html({tag, _, entries}, indent, options) when tag in [:strong, :b] do
-    inline_text("**", traverse_erlang_html(entries, indent, options), options)
-  end
-
-  defp traverse_erlang_html({:code, _, entries}, indent, options) do
-    inline_text("`", traverse_erlang_html(entries, indent, options), options)
-  end
-
-  defp traverse_erlang_html({:pre, _, [{:code, _, entries}]}, indent, options) do
-    string =
-      entries
-      |> traverse_erlang_html(indent, options)
-      |> IO.iodata_to_binary()
-
-    ["#{indent}    ", String.replace(string, "\n", "\n#{indent}    ")] |> newline_cons()
-  end
-
-  defp traverse_erlang_html({:a, attributes, entries}, indent, options) do
-    if href = attributes[:href] do
-      [traverse_erlang_html(entries, indent, options), ?\s, ?(, href, ?)]
-    else
-      traverse_erlang_html(entries, indent, options)
-    end
-  end
-
-  defp traverse_erlang_html({:dl, _, entries}, indent, options) do
-    traverse_erlang_html(entries, indent, options)
-  end
-
-  defp traverse_erlang_html({:dt, _, entries}, indent, options) do
-    [
-      "#{indent}  ",
-      bullet_text(options) | handle_erlang_html_text(entries, indent <> "    ", options)
-    ]
-  end
-
-  defp traverse_erlang_html({:dd, _, entries}, indent, options) do
-    ["#{indent}    " | handle_erlang_html_text(entries, indent <> "    ", options)]
-  end
-
-  defp traverse_erlang_html({:ul, attributes, entries}, indent, options) do
-    if attributes[:class] == "types" do
-      types =
-        for {:li, _, lines} <- entries,
-            line <- lines,
-            do: ["#{indent}    ", traverse_erlang_html(line, indent <> "    ", options), ?\n]
-
-      if types != [] do
-        ["#{indent}Typespecs:\n\n", types, ?\n]
-      else
-        []
-      end
-    else
-      for {:li, _, lines} <- entries do
-        [
-          "#{indent}  ",
-          bullet_text(options) | handle_erlang_html_text(lines, indent <> "    ", options)
-        ]
-      end
-    end
-  end
-
-  defp traverse_erlang_html({:ol, _, entries}, indent, options) do
-    for {{:li, _, lines}, i} <- Enum.with_index(entries, 1) do
-      [
-        "#{indent}  ",
-        Integer.to_string(i),
-        ". " | handle_erlang_html_text(lines, indent <> "     ", options)
-      ]
-    end
-  end
-
-  defp traverse_erlang_html({tag, _, entries}, indent, options) do
-    [
-      indent <> "<#{tag}>\n",
-      traverse_erlang_html(entries, indent <> "    ", options)
-      |> IO.iodata_to_binary()
-      |> String.trim_trailing(),
-      "\n" <> indent <> "</#{tag}>"
-    ]
-    |> newline_cons()
-  end
-
-  defp newline_cons(text) do
-    [text | "\n\n"]
-  end
-
-  defp handle_erlang_html_text(entries, indent, options) do
-    if Enum.all?(entries, &inline_html?/1) do
-      entries
-      |> traverse_erlang_html(indent, options)
-      |> IO.iodata_to_binary()
-      |> String.split(@spaces)
-      |> wrap_text(options[:width], indent, true, "", [])
-      |> tl()
-      |> newline_cons()
-    else
-      entries
-      |> traverse_erlang_html(indent, options)
-      |> IO.iodata_to_binary()
-      |> String.trim_leading()
-    end
-  end
-
-  defp inline_html?(binary) when is_binary(binary), do: true
-  defp inline_html?({tag, _, _}) when tag in [:a, :code, :em, :i, :strong, :b, :br], do: true
-  defp inline_html?(_), do: false
-
-  ## Markdown
-
-  def print_markdown(doc, options) do
-    options = Keyword.merge(default_options(), options)
-
     doc
     |> String.split(["\r\n", "\n"], trim: false)
     |> Enum.map(&String.trim_trailing/1)
@@ -322,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)
@@ -368,85 +106,40 @@ defmodule IO.ANSI.Docs 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
   end
 
-  ### Headings
+  ## Headings
 
   defp write_heading(heading, rest, text, indent, options) do
     write_text(text, indent, options)
     write(:doc_headings, heading, options)
-    newline_after_block(options)
+    newline_after_block()
     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 write_empty_quote_line(options) do
-    options
-    |> quote_prefix()
-    |> IO.puts()
-  end
-
-  ### Lists
+  ## Lists
 
   defp process_rest(stripped, rest, count, text, indent, options) do
     case stripped do
       <<bullet, ?\s, item::binary>> when bullet in @bullets ->
         write_text(text, indent, options)
-        process_list(bullet_text(options), item, rest, count, 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
@@ -457,18 +150,15 @@ defmodule IO.ANSI.Docs do
     entry = if indent == "", do: "  " <> entry, else: entry
     new_indent = indent <> String.duplicate(" ", String.length(entry))
 
-    {contents, rest, done} =
-      process_list_next(rest, count, byte_size(new_indent) - byte_size(indent), [])
-
+    {contents, rest, done} = process_list_next(rest, count, byte_size(new_indent), [])
     process(contents, [indent <> entry <> line, :no_wrap], new_indent, options)
 
-    if done, do: newline_after_block(options)
+    if done, do: newline_after_block()
     process(rest, [], indent, options)
   end
 
   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}
@@ -484,26 +174,20 @@ 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
   end
 
-  ### Text
+  ## Text
 
   defp write_text(text, indent, options) do
     case Enum.reverse(text) do
@@ -517,26 +201,17 @@ 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)
-    |> String.split(@spaces)
-    |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap, prefix)
-
-    unless no_wrap, do: newline_after_block(options)
-  end
-
-  defp format_text(text, options) do
-    text
-    |> handle_links()
+    |> handle_links
     |> handle_inline(options)
+    |> String.split(@spaces)
+    |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap)
+
+    unless no_wrap, do: newline_after_block()
   end
 
-  ### Code blocks
+  ## Code blocks
 
   defp process_code([], code, indent, options) do
     write_code(code, indent, options)
@@ -575,21 +250,21 @@ defmodule IO.ANSI.Docs do
 
   defp write_code(code, indent, options) do
     write(:doc_code, "#{indent}    #{Enum.join(Enum.reverse(code), "\n#{indent}    ")}", options)
-    newline_after_block(options)
+    newline_after_block()
   end
 
-  ### Tables
+  ## Tables
 
   defp process_table(lines, indent, options) do
     {table, rest} = Enum.split_while(lines, &table_line?/1)
     table_lines(table, options)
-    newline_after_block(options)
+    newline_after_block()
     process(rest, [], indent, options)
   end
 
   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 =
@@ -601,26 +276,28 @@ defmodule IO.ANSI.Docs do
         end
       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(~r{(?<!\\)\|})
+    |> String.trim()
+    |> String.split(" | ")
     |> Enum.map(&render_column(&1, options))
   end
 
   defp render_column(col, options) do
     col =
       col
-      |> String.trim()
       |> String.replace("\\\|", "|")
+      |> String.trim()
       |> handle_links
       |> handle_inline(options)
-
     {col, length_without_escape(col, 0)}
   end
 
@@ -633,7 +310,6 @@ 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)
@@ -651,7 +327,8 @@ 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
@@ -661,14 +338,14 @@ defmodule IO.ANSI.Docs do
     end
   end
 
-  defp table_header?(line) do
-    Enum.all?(line, fn {col, _} -> table_header_column?(col) end)
+  defp table_header?(row) do
+    Enum.all?(row, fn {col, _} -> table_header_column?(col) end)
   end
 
-  defp table_header_column?(":" <> rest), do: table_header_contents?(rest)
-  defp table_header_column?(col), do: table_header_contents?(col)
+  defp table_header_column?(":" <> row), do: table_header_contents?(row)
+  defp table_header_column?(row), do: table_header_contents?(row)
 
-  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
@@ -685,31 +362,26 @@ defmodule IO.ANSI.Docs do
     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))
+    pad = if rem(length, 2) == 0, do: 1, else: rem(width, 2)
+    spaces = div(width, 2) - div(length, 2)
+    String.duplicate(" ", spaces) <> col <> String.duplicate(" ", spaces + pad)
   end
 
   defp generate_table_cell({{{col, length}, width}, :right}) do
-    ansi_diff = byte_size(col) - length
-    String.pad_leading(col, width + ansi_diff)
+    String.duplicate(" ", width - length) <> col
   end
 
-  defp generate_table_cell({{{col, length}, width}, :left}) do
-    ansi_diff = byte_size(col) - length
-    String.pad_trailing(col, width + ansi_diff)
+  defp generate_table_cell({{{col, length}, width}, _}) do
+    col <> String.duplicate(" ", width - length)
   end
 
   defp table_line?(line) do
-    line =~ ~r/[:\ -]\|[:\ -]/
+    line =~ " | "
   end
 
   ## Helpers
@@ -722,34 +394,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, maybe_reset(options)])
+    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, [])
-    |> tl()
-    |> 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, ?\n | 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
@@ -796,22 +457,24 @@ 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 `.
+  # We have four entries: **, *, _ and `.
   #
-  # The first four 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 two has two characters,
-  # we need to handle 3 cases:
+  # The first three behave the same while the last one is simpler
+  # when it comes to delimiters. But, since the first has two
+  # characters, we need to handle 3 cases:
   #
-  # 1. __ and **
+  # 1. **
   # 2. _ and *
   # 3. `
   #
@@ -820,13 +483,12 @@ 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
+  # Inline start
 
-  defp handle_inline(<<mark, mark, rest::binary>>, options) when mark in @single do
-    handle_inline(rest, [mark | mark], [<<mark, mark>>], [], options)
+  defp handle_inline(<<?*, ?*, rest::binary>>, options) do
+    handle_inline(rest, ?d, ["**"], [], options)
   end
 
   defp handle_inline(<<mark, rest::binary>>, options) when mark in @single do
@@ -837,34 +499,32 @@ defmodule IO.ANSI.Docs do
     handle_inline(rest, nil, [], [], options)
   end
 
-  ### Inline delimiters
+  # Inline delimiters
 
-  defp handle_inline(<<delimiter, mark, mark, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and delimiter in @delimiters and mark in @single do
-    acc = [delimiter, Enum.reverse(buffer) | acc]
-    handle_inline(rest, [mark | mark], [<<mark, mark>>], acc, options)
+  defp handle_inline(<<delimiter, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
+      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
+  # Clauses for handling escape
 
-  defp handle_inline(<<?\\, ?\\, mark, mark, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and mark in @single do
-    acc = [?\\, Enum.reverse(buffer) | acc]
-    handle_inline(rest, [mark | mark], [<<mark, mark>>], acc, options)
+  defp handle_inline(<<?\\, ?\\, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
+      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
 
@@ -873,31 +533,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
+  # Inline end
 
-  defp handle_inline(<<mark, mark, delimiter, rest::binary>>, [mark | 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)
+  defp handle_inline(<<?*, ?*, delimiter, rest::binary>>, ?d, 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(<<mark, mark, rest::binary>>, [mark | mark], buffer, acc, options)
-       when rest == "" and mark in @single do
+  defp handle_inline(<<?*, ?*, rest::binary>>, ?d, buffer, acc, options)
+      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
 
@@ -905,60 +564,34 @@ defmodule IO.ANSI.Docs do
     handle_inline(rest, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
-  ### Catch all
+  # Catch all
 
   defp handle_inline(<<char, rest::binary>>, mark, buffer, acc, options) do
     handle_inline(rest, mark, [char | buffer], acc, options)
   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
-    [mark | t] = Enum.reverse(buffer)
-    inline_text(mark, t, options)
-  end
-
-  ## Helpers
-
-  defp quote_prefix(options), do: "#{color(:doc_quote, options)}> #{maybe_reset(options)}"
-
-  defp heading(text, n, options) do
-    [color(:doc_headings, options), String.duplicate("#", n), " ", text, maybe_reset(options)]
-  end
-
-  defp inline_text(mark, text, options) do
-    if options[:enabled] do
-      [[color_for(mark, options) | text] | IO.ANSI.reset()]
-    else
-      [[mark | text] | mark]
-    end
+    [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_bold, colors)
+      "`"  -> color(:doc_inline_code, colors)
+      "_"  -> color(:doc_underline, colors)
+      "*"  -> color(:doc_bold, colors)
       "**" -> color(:doc_bold, colors)
-      "_" -> color(:doc_underline, colors)
-      "*" -> color(:doc_underline, colors)
-      "`" -> color(:doc_inline_code, colors)
     end
   end
 
-  defp bullet_text(options) do
-    if options[:enabled], do: @bullet_text_unicode, else: @bullet_text_ascii
-  end
-
   defp color(style, colors) do
-    IO.ANSI.format_fragment(colors[style], colors[:enabled])
+    color = colors[style]
+    IO.ANSI.format_fragment(color, colors[:enabled])
   end
 
-  defp newline_after_block(options) do
-    IO.puts(maybe_reset(options))
-  end
-
-  defp maybe_reset(options) do
-    if options[:enabled], do: IO.ANSI.reset(), else: ""
-  end
+  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.
@@ -26,11 +25,7 @@ defmodule IO.Stream do
 
   defstruct device: nil, raw: true, line_or_bytes: :line
 
-  @type t :: %__MODULE__{
-          device: IO.device(),
-          raw: boolean(),
-          line_or_bytes: :line | non_neg_integer()
-        }
+  @type t :: %__MODULE__{}
 
   @doc false
   def __build__(device, raw, line_or_bytes) do
@@ -46,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
@@ -60,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
@@ -74,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,23 +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,
-    pry: false
-  }
-
-  @standalone_opts ["-h", "--help", "--short-version"]
+  @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.
@@ -27,22 +13,15 @@ defmodule Kernel.CLI do
 
     {config, argv} = parse_argv(argv)
     System.argv(argv)
-    System.no_halt(config.no_halt)
 
-    if config.pry do
-      Application.put_env(:elixir, :dbg_callback, {IEx.Pry, :dbg, []})
-    end
-
-    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 """
@@ -53,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
@@ -69,51 +47,32 @@ 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.
-  """
+  @doc false
   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/1))
-          [formatted, padded_blame]
-
+          [Exception.format_banner(kind, reason, stacktrace),
+           pad(FunctionClauseError.blame(blamed, &inspect/1, &blame_match/2))]
         _ ->
           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
@@ -131,23 +90,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)
 
@@ -155,7 +113,6 @@ defmodule Kernel.CLI do
       {^pid, res} ->
         :erlang.demonitor(ref, [:flush])
         res
-
       {:DOWN, ^ref, _, _, other} ->
         print_error({:EXIT, pid}, other, [])
         {:shutdown, 1}
@@ -171,7 +128,6 @@ 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
@@ -180,14 +136,18 @@ defmodule Kernel.CLI do
   ## Error handling
 
   defp print_error(kind, reason, stacktrace) do
-    IO.write(:stderr, format_error(kind, reason, stacktrace))
+    IO.write :stderr, format_error(kind, reason, stacktrace)
   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(%{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
+    if IO.ANSI.enabled? do
       [color | Macro.to_string(node)]
       |> IO.ANSI.format(true)
       |> IO.iodata_to_binary()
@@ -200,10 +160,9 @@ defmodule Kernel.CLI 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_locals] ++
-                      [:elixir_erl, :elixir_erl_clauses, :elixir_erl_compiler, :elixir_erl_pass] ++
-                      [Kernel.ErrorHandler, Module.ParallelChecker]
+  @elixir_internals [:elixir, :elixir_expand, :elixir_compiler, :elixir_module,
+                     :elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map,
+                     :elixir_erl, :elixir_erl_clauses, :elixir_erl_pass, Kernel.ErrorHandler]
 
   defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
     prune_stacktrace(t)
@@ -223,92 +182,65 @@ defmodule Kernel.CLI do
 
   # Parse shared options
 
-  defp halt_standalone(opt) do
-    IO.puts(:stderr, "#{opt} : Standalone options can't be combined with other options")
-    System.halt(1)
-  end
-
-  defp parse_shared([opt | _], _config) when opt in @standalone_opts do
-    halt_standalone(opt)
-  end
-
-  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])
+  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]
     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
 
-    if t != [] do
-      halt_standalone(opt)
-    else
-      System.halt(0)
-    end
+    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]})
-  end
-
-  defp parse_shared(["--rpc-eval" | _], config) do
-    new_config = %{config | errors: ["--rpc-eval : wrong number of arguments" | config.errors]}
-    {[], new_config}
+    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
@@ -320,11 +252,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 | pry: true})
+    parse_iex t, config
   end
 
   defp parse_argv(["-S", h | t], config) do
@@ -334,10 +266,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}
@@ -356,46 +287,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
 
@@ -409,20 +330,26 @@ defmodule Kernel.CLI do
     {config, t}
   end
 
+  # 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
+  end
+
+  defp parse_iex([opt, _ | t], config) when opt in ["--remsh"] do
+    parse_iex t, config
+  end
+
   defp parse_iex(["-S", h | t], config) do
     {%{config | commands: [{:script, h} | config.commands]}, t}
   end
 
-  # These clauses are here so that Kernel.CLI does not error out with "unknown option"
-  defp parse_iex(["--dot-iex", _ | t], config), do: parse_iex(t, config)
-  defp parse_iex(["--remsh", _ | t], config), do: parse_iex(t, config)
-
-  defp parse_iex(["--no-pry" | t], config), do: parse_iex(t, %{config | pry: false})
-
   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
 
@@ -433,32 +360,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
@@ -466,7 +383,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
@@ -474,7 +391,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
@@ -484,7 +401,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
@@ -494,12 +411,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
@@ -512,36 +424,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_file: &IO.puts("Compiling #{Path.relative_to_cwd(&1)}")]
-            else
-              [
-                each_long_compilation:
-                  &IO.puts("Compiling #{Path.relative_to_cwd(&1)} (it's taking more than 10s)")
-              ]
-            end
-
-          profile_opts =
-            if config.profile do
-              [profile: config.profile]
+              [each_long_compilation: &IO.puts("Compiling #{&1} (it's taking more than 5s)")]
             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
@@ -549,24 +442,23 @@ defmodule Kernel.CLI do
 
   defp filter_patterns(pattern) do
     pattern
-    |> Path.expand()
-    |> 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} ->
+      Enum.reduce patterns, {[], []}, fn pattern, {files, missing} ->
         case filter_patterns(pattern) do
           [] -> {files, [pattern | missing]}
           match -> {match ++ files, missing}
         end
-      end)
+      end
 
     case missing do
       [] -> {:ok, :lists.usort(files)}
-      _ -> {:missing, :lists.usort(missing)}
+      _  -> {:missing, :lists.usort(missing)}
     end
   end
 
@@ -584,7 +476,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
-    {compiler_pid, file_pid} = :erlang.get(:elixir_compiler_info)
-    ref = :erlang.make_ref()
-    modules = :elixir_module.compiler_modules()
-    send(compiler_pid, {:waiting, kind, self(), ref, file_pid, module, modules, deadlock})
+  def ensure_compiled(module, kind) do
+    parent = :erlang.get(:elixir_compiler_pid)
+    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,32 +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)
-  end
-
-  @doc false
-  def add_export(pid, module) when is_atom(module) do
-    :gen_server.cast(pid, {:add_export, module})
+    :gen_server.cast(pid, :stop)
   end
 
   @doc false
@@ -45,13 +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 import_dispatch(pid, module, fa, mode) when is_atom(module) do
-    :gen_server.cast(pid, {:import_dispatch, module, fa, mode})
+  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, line, mode) when is_atom(module) do
+    :gen_server.cast(pid, {:import_dispatch, module, fa, line, mode})
   end
 
   @doc false
@@ -59,26 +81,6 @@ defmodule Kernel.LexicalTracker do
     :gen_server.cast(pid, {:alias_dispatch, module})
   end
 
-  @doc false
-  def import_quoted(pid, module, function, arities) when is_atom(module) do
-    :gen_server.cast(pid, {:import_quoted, module, function, arities})
-  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()
@@ -93,137 +95,99 @@ defmodule Kernel.LexicalTracker do
 
   @doc false
   def collect_unused_imports(pid) do
-    unused(pid, :unused_imports)
+    unused(pid, :import)
   end
 
   @doc false
   def collect_unused_aliases(pid) do
-    unused(pid, :unused_aliases)
+    unused(pid, :alias)
   end
 
   defp unused(pid, tag) do
-    :gen_server.call(pid, tag, @timeout)
+    :gen_server.call(pid, {:unused, tag}, @timeout)
   end
 
   # Callbacks
 
-  def init(:ok) do
-    state = %{
-      aliases: %{},
-      imports: %{},
-      references: %{},
-      exports: %{},
-      cache: %{},
-      compile_env: :ordsets.new(),
-      file: nil
-    }
-
-    {:ok, state}
+  def init(dest) do
+    {:ok, %{directives: %{}, references: %{}, compile: %{},
+            runtime: %{}, dest: dest, cache: %{}}}
   end
 
   @doc false
-  def handle_call(:unused_aliases, _from, state) do
-    {:reply, Enum.sort(state.aliases), state}
+  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}
+
+    {:reply, Enum.sort(directives), state}
   end
 
-  def handle_call(:unused_imports, _from, state) do
-    {:reply, Enum.sort(state.imports), state}
+  def handle_call(:remote_references, _from, state) do
+    {:reply, partition(Enum.to_list(state.references), [], []), state}
   end
 
-  def handle_call(:references, _from, state) do
-    {compile, runtime} = partition(Map.to_list(state.references), [], [])
-    {:reply, {compile, Map.keys(state.exports), runtime, state.compile_env}, state}
+  def handle_call(:remote_dispatches, _from, state) do
+    {:reply, {state.compile, state.runtime}, state}
+  end
+
+  def handle_call(:dest, _from, state) do
+    {:reply, state.dest, state}
   end
 
   def handle_call({:read_cache, key}, _from, %{cache: cache} = state) do
-    {:reply, Map.get(cache, key), state}
-  end
-
-  def handle_call(:stop, _from, state) do
-    {:stop, :normal, :ok, state}
+    {:reply, Map.fetch!(cache, key), state}
   end
 
   def handle_cast({:write_cache, key, value}, %{cache: cache} = state) do
-    {:noreply, %{state | cache: Map.put(cache, key, value)}}
+    {:noreply, Map.put(state, :cache, Map.put(cache, key, value))}
   end
 
-  def handle_cast({:remote_dispatch, module, mode}, state) do
+  def handle_cast({:remote_reference, module, mode}, state) do
+    {:noreply, %{state | references: add_reference(state.references, module, mode)}}
+  end
+
+  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}, mode}, state) do
-    %{imports: imports, references: references} = state
+  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)
 
-    imports =
-      case imports do
-        %{^module => modules_and_fas} ->
-          modules_and_fas
-          |> Map.delete(module)
-          |> Map.delete({function, arity})
-          |> then(&Map.put(imports, module, &1))
-
-        %{} ->
-          imports
-      end
-
-    references = add_reference(references, module, mode)
-    {:noreply, %{state | imports: imports, references: references}}
+    {:noreply, state}
   end
 
-  def handle_cast({:alias_dispatch, module}, %{aliases: aliases} = state) do
-    {:noreply, %{state | aliases: Map.delete(aliases, module)}}
-  end
-
-  def handle_cast({:import_quoted, module, function, arities}, state) do
-    %{imports: imports} = state
-
-    imports =
-      case imports do
-        %{^module => modules_and_fas} ->
-          arities
-          |> Enum.reduce(modules_and_fas, &Map.delete(&2, {function, &1}))
-          |> Map.delete(module)
-          |> then(&Map.put(imports, module, &1))
-
-        %{} ->
-          imports
-      end
-
-    {:noreply, %{state | imports: imports}}
-  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_export, module}, state) do
-    {:noreply, put_in(state.exports[module], true)}
+  def handle_cast({:alias_dispatch, module}, state) do
+    {:noreply, %{state | directives: add_dispatch(state.directives, module, :alias)}}
   end
 
   def handle_cast({:add_import, module, fas, line, warn}, state) do
-    if warn do
-      imports = for module_or_fa <- [module | fas], do: {module_or_fa, line}, into: %{}
-      {:noreply, put_in(state.imports[module], imports)}
-    else
-      {:noreply, state}
-    end
+    directives =
+      state.directives
+      |> Enum.reject(&match?({{:import, {^module, _, _}}, _}, &1))
+      |> :maps.from_list
+      |> add_directive(module, line, warn, :import)
+
+    directives =
+      Enum.reduce(fas, directives, fn {function, arity}, directives ->
+        add_directive(directives, {module, function, arity}, line, warn, :import)
+      end)
+
+    {:noreply, %{state | directives: directives}}
   end
 
   def handle_cast({:add_alias, module, line, warn}, state) do
-    if warn do
-      {:noreply, put_in(state.aliases[module], line)}
-    else
-      {:noreply, state}
-    end
+    {:noreply, %{state | directives: add_directive(state.directives, module, line, warn, :alias)}}
+  end
+
+  def handle_cast(:stop, state) do
+    {:stop, :normal, state}
   end
 
   @doc false
@@ -243,21 +207,60 @@ 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 references do
-      %{^module => _} -> references
-      %{} -> 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
+
+  defp add_import_dispatch(state, module, function, arity) 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
+
+  # In the map we keep imports and aliases.
+  # If the value is a line, it was imported/aliased and has a pending warning
+  # 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
+    :maps.put({tag, module_or_mfa}, marker, directives)
+  end
+
+  defp add_dispatch(directives, module_or_mfa, tag) do
+    :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,52 +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.
   """
 
-  @typedoc "The line. 0 indicates no line."
-  @type line() :: non_neg_integer()
-  @type location() :: line() | {pos_integer(), column :: non_neg_integer}
-  @type warning() :: {file :: Path.t(), location(), message :: String.t()}
-  @type error() :: {file :: Path.t(), location(), message :: String.t()}
-
-  @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, 0) do
-    case :erlang.get(:elixir_compiler_info) do
-      {compiler, _} ->
-        file = :erlang.get(:elixir_compiler_file)
-        dest = :erlang.get(:elixir_compiler_dest)
-
-        {:error_handler, error_handler} = :erlang.process_info(self(), :error_handler)
-        {_parent, checker} = Module.ParallelChecker.get()
-
-        Task.async(fn ->
-          send(compiler, {:async, self()})
-          Module.ParallelChecker.put(compiler, checker)
-          :erlang.put(:elixir_compiler_info, {compiler, self()})
-          :erlang.put(:elixir_compiler_file, file)
-          dest != :undefined and :erlang.put(:elixir_compiler_dest, dest)
-          :erlang.process_flag(:error_handler, error_handler)
-          fun.()
-        end)
-
-      :undefined ->
-        raise ArgumentError,
-              "cannot spawn parallel compiler task because " <>
-                "the current file is not being compiled/required"
-    end
-  end
-
   @doc """
   Compiles the given files.
 
@@ -55,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
@@ -69,720 +24,325 @@ 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, warnings}` - to continue compilation with a list of
-        further modules to compile
-      * `{:runtime, modules, warnings}` - to stop compilation and verify the list
-        of modules because dependent modules have changed
+    * `:each_warning` - for each warning, invokes the callback passing
+      the file, line number, and warning message
 
-    * `:long_compilation_threshold` - the timeout (in seconds) to check for modules
-      taking too long to compile. For each file that exceeds the threshold, the
-      `:each_long_compilation` callback is invoked. From Elixir v1.11, only the time
-      spent compiling the actual module is taken into account by the threshold, the
-      time spent waiting is not considered. Defaults to `10` seconds.
-
-    * `: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"
-  @spec compile([Path.t()], keyword()) :: {:ok, [atom], [warning]} | {:error, [error], [warning]}
-  def compile(files, options \\ []) when is_list(options) do
-    spawn_workers(files, :compile, options)
+  def files(files, options \\ [])
+
+  def files(files, options) when is_list(options) do
+    spawn_compilers(files, nil, options)
   end
 
   @doc """
-  Compiles the given files and writes resulting BEAM files into path.
-
-  See `compile/2` for more information.
+  Compiles the given files to the given path.
+  Read `files/2` for more information.
   """
-  @doc since: "1.6.0"
-  @spec compile_to_path([Path.t()], Path.t(), keyword()) ::
-          {:ok, [atom], [warning]} | {:error, [error], [warning]}
-  def compile_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
-    spawn_workers(files, {:compile, path}, 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 """
-  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
-
-  """
-  @doc since: "1.6.0"
-  @spec require([Path.t()], keyword()) ::
-          {:ok, [atom], [warning]} | {:error, [error], [warning]}
-  def require(files, options \\ []) when is_list(options) do
-    spawn_workers(files, :require, options)
-  end
-
-  @doc """
-  Prints a warning returned by the compiler.
-  """
-  @doc since: "1.13.0"
-  @spec print_warning(warning) :: :ok
-  def print_warning({file, location, warning}) do
-    :elixir_errors.print_warning(location, file, warning)
-  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)
-    {:ok, checker} = Module.ParallelChecker.start_link(schedulers)
 
-    try do
-      outcome = spawn_workers(schedulers, checker, files, output, options)
-      {outcome, Code.get_compiler_option(:warnings_as_errors)}
-    else
-      {{:ok, _, [_ | _] = warnings}, true} ->
-        message = "Compilation failed due to warnings while using the --warnings-as-errors option"
-        IO.puts(:stderr, message)
-        {:error, warnings, []}
+    result = spawn_compilers(%{
+      entries: files,
+      original: files,
+      output: path,
+      options: options,
+      waiting: [],
+      queued: [],
+      schedulers: schedulers,
+      result: [],
+    })
 
-      {{:ok, outcome, warnings}, _} ->
-        beam_timestamp = Keyword.get(options, :beam_timestamp)
-        {:ok, write_module_binaries(outcome, output, beam_timestamp), warnings}
-
-      {{:error, errors, warnings}, true} ->
-        {:error, errors ++ warnings, []}
-
-      {{:error, errors, warnings}, _} ->
-        {:error, errors, warnings}
-    after
-      Module.ParallelChecker.stop(checker)
+    # 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, "Compilation failed due to warnings while using the --warnings-as-errors option"
+        exit({:shutdown, 1})
     end
   end
 
-  defp spawn_workers(schedulers, checker, files, output, options) do
-    threshold = Keyword.get(options, :long_compilation_threshold, 10) * 1000
-    timer_ref = Process.send_after(self(), :threshold_check, threshold)
-
-    {outcome, state} =
-      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),
-        profile: profile_init(Keyword.get(options, :profile)),
-        output: output,
-        timer_ref: timer_ref,
-        long_compilation_threshold: threshold,
-        schedulers: schedulers,
-        checker: checker
-      })
-
-    Process.cancel_timer(state.timer_ref)
-
-    receive do
-      :threshold_check -> :ok
-    after
-      0 -> :ok
-    end
-
-    outcome
-  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} ->
-        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}, state}
-  end
-
-  defp maybe_check_modules(result, runtime_modules, state) do
-    %{profile: profile, checker: checker} = state
-
-    compiled_modules =
-      for {{:module, module}, _} <- result,
-          do: module
-
-    profile_checker(profile, compiled_modules, runtime_modules, fn ->
-      Module.ParallelChecker.verify(checker, runtime_modules)
-    end)
-  end
-
-  defp profile_init(:time), do: {:time, System.monotonic_time(), 0}
-  defp profile_init(nil), do: :none
-
-  defp profile_checker({: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(:none, _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
-    {files, waiting} =
+  defp spawn_compilers(%{entries: [{ref, found} | t], waiting: waiting} = state) do
+    waiting =
       case List.keytake(waiting, ref, 2) do
-        {{_kind, pid, ^ref, file_pid, _on, _defining, _deadlock}, waiting} ->
-          send(pid, {ref, found})
-          {update_timing(files, file_pid, :waiting), waiting}
-
+        {{_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.
-          {files, waiting}
+          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, dest: dest, checker: checker} = 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 ->
-        Module.ParallelChecker.put(parent, checker)
-        :erlang.put(:elixir_compiler_info, {parent, self()})
+      :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)
+        result =
+          try do
+            _ = if output do
+              :elixir_compiler.file_to_path(file, output)
+            else
+              :elixir_compiler.file(file, Keyword.get(options, :dest))
+            end
+            :ok
+          catch
+            kind, reason ->
+              {kind, reason, System.stacktrace}
           end
-        catch
-          kind, reason ->
-            send(parent, {:file_error, self(), file, {kind, reason, __STACKTRACE__}})
-        end
 
+        send(parent, {:file_compiled, self(), file, result})
         exit(:shutdown)
-      end)
+      end
 
-    file_data = %{
-      pid: pid,
-      ref: ref,
-      file: file,
-      timestamp: System.monotonic_time(),
-      compiling: 0,
-      waiting: 0,
-      warned: false
-    }
+    timeout = Keyword.get(options, :long_compilation_threshold, 10) * 1_000
+    timer_ref = Process.send_after(self(), {:timed_out, pid}, timeout)
 
-    files = [file_data | 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
-    cycle_return = each_cycle_return(state.each_cycle.())
-    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 cycle_return do
-      {:runtime, dependent_modules, extra_warnings} ->
-        verify_modules(result, extra_warnings ++ 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, [], extra_warnings} ->
-        verify_modules(result, extra_warnings ++ warnings, [], state)
-
-      {:compile, more, extra_warnings} ->
-        spawn_workers(more, 0, [], [], result, extra_warnings ++ 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
+    |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
+    |> Enum.sort_by(&length(elem(&1, 1)))
+    |> case do
+      [{_on, refs} | _] -> spawn_compilers(%{state | entries: refs})
+      [] -> handle_deadlock(waiting, queued)
     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: 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 without a known definition (deadlock = soft)
-    #   2. Code.ensure_compiled/1 checks with a known definition (deadlock = soft)
-    #   3. Struct/import/require/ensure_compiled! checks without a known definition (deadlock = hard)
-    #   4. Modules without a known definition
-    #   5. Code invocation (deadlock = raise)
-    #
-    # The reason for step 3 and 4 is to not treat typos as deadlocks and
-    # help developers handle those sooner. However, this can have false
-    # positives in case multiple modules are defined in the same file
-    # and the module we are waiting for is defined later on.
-    #
-    # Finally, note there is no difference between hard and raise, the
-    # difference is where the raise is happening, inside the compiler
-    # or in the caller.
-
-    deadlocked =
-      deadlocked(waiting, :soft, false) ||
-        deadlocked(waiting, :soft, true) || deadlocked(waiting, :hard, false) ||
-        without_definition(waiting, files)
-
-    if deadlocked do
-      spawn_workers(deadlocked, spawned, waiting, files, result, warnings, state)
+  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
-      errors = handle_deadlock(waiting, files)
-      {{:error, errors, warnings}, state}
+      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: :none} = state) do
-    state
-  end
-
-  defp cycle_timing(result, %{profile: {:time, cycle_start, module_counter}} = state) do
-    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 | profile: {:time, now, num_modules}}
-  end
-
-  defp count_modules(result) do
-    Enum.count(result, &match?({{:module, _}, _}, &1))
-  end
-
-  defp each_cycle_return({kind, modules, warnings}), do: {kind, modules, warnings}
-
-  defp each_cycle_return(other) do
-    IO.warn(
-      "the :each_cycle callback must return a tuple of format {:compile | :runtime, modules, warnings}"
-    )
-
-    case other do
-      {kind, modules} -> {kind, modules, []}
-      modules when is_list(modules) -> {:compile, modules, []}
-    end
-  end
-
-  # The goal of this function is to find leaves in the dependency graph,
-  # i.e. to find code that depends on code that we know is not being defined.
-  # Note that not all files have been compiled yet, so they may not be in waiting.
-  defp without_definition(waiting, files) do
-    nilify_empty(
-      for %{pid: pid} <- files,
-          {_, _, ref, ^pid, on, _, _} <- waiting,
-          not defining?(on, waiting),
-          do: {ref, :not_found}
-    )
-  end
-
-  defp deadlocked(waiting, type, defining?) do
-    nilify_empty(
-      for {_, _, ref, _, on, _, ^type} <- waiting,
-          defining?(on, waiting) == defining?,
-          do: {ref, :deadlock}
-    )
-  end
-
-  defp defining?(on, waiting) do
-    Enum.any?(waiting, fn {_, _, _, _, _, defining, _} -> on in defining end)
-  end
-
-  defp nilify_empty([]), do: nil
-  defp nilify_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}
-
-        result = Map.put(result, {kind, module}, true)
-        spawn_workers(available ++ queue, spawned, waiting, files, result, warnings, state)
+        spawn_compilers(%{state | entries: available ++ entries, result: [{:struct, module} | result]})
 
       {:module_available, child, ref, file, module, binary} ->
-        state.each_module.(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}
 
-        result = Map.put(result, {:module, module}, binary)
-        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, _file_pid, _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_pid, ref, file_pid, on, defining, deadlock?} ->
-        # If we already got what we were waiting for, do not put it on waiting.
-        # If we're waiting on ourselves, send :found so that we can crash with
-        # a better error.
-        {files, waiting} =
-          if Map.has_key?(result, {kind, on}) or on in defining do
-            send(child_pid, {ref, :found})
-            {files, 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 :lists.any(&match?({^kind, ^on}, &1), result) or on in defining do
+            send child, {ref, :found}
+            waiting
           else
-            files = update_timing(files, file_pid, :compiling)
-            {files, [{kind, child_pid, ref, file_pid, 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})
 
-      :threshold_check ->
-        files =
-          for data <- files do
-            if data.warned or List.keymember?(waiting, data.pid, 1) do
-              data
-            else
-              data = update_timing(data, :compiling)
-              data = maybe_warn_long_compilation(data, state)
-              data
-            end
-          end
+      {:timed_out, child} ->
+        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)
 
-        timer_ref = Process.send_after(self(), :threshold_check, state.long_compilation_threshold)
-        state = %{state | timer_ref: timer_ref}
-        spawn_workers(queue, spawned, waiting, files, result, warnings, state)
-
-      {:warning, file, location, message} ->
-        file = file && Path.absname(file)
-        message = :unicode.characters_to_binary(message)
-        warning = {file, location, message}
-        wait_for_messages(queue, spawned, waiting, files, result, [warning | warnings], state)
-
-      {:file_ok, child_pid, ref, file, lexical} ->
-        state.each_file.(file, lexical)
-        send(child_pid, ref)
+      {:warning, file, line, message} ->
+        if callback = Keyword.get(options, :each_warning) do
+          callback.(file, line, message)
+        end
+        wait_for_messages(state)
 
+      {:file_compiled, child_pid, file, :ok} ->
         discard_down(child_pid)
-        new_files = discard_and_maybe_log_file(files, child_pid, state)
 
-        # Sometimes we may have spurious entries in the waiting list
-        # because someone invoked try/rescue UndefinedFunctionError
+        if callback = Keyword.get(options, :each_file) do
+          callback.(file)
+        end
+
+        cancel_waiting_timer(queued, child_pid)
+
+        # Sometimes we may have spurious entries in the waiting
+        # list because someone invoked try/rescue UndefinedFunctionError
+        new_entries = List.delete(entries, child_pid)
+        new_queued  = List.keydelete(queued, child_pid, 0)
         new_waiting = List.keydelete(waiting, child_pid, 1)
-        spawn_workers(queue, spawned - 1, new_waiting, new_files, result, warnings, state)
+        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
 
-      {:file_cancel, child_pid} ->
+      {:file_compiled, child_pid, file, {kind, reason, stack}} ->
         discard_down(child_pid)
-        new_files = Enum.reject(files, &(&1.pid == child_pid))
-        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)
-        discard_down(child_pid)
-        files |> Enum.reject(&(&1.pid == child_pid)) |> terminate()
-        {{:error, [to_error(file, kind, reason, stack)], warnings}, state}
+        terminate(queued)
 
-      {: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}, state}
-        end
+      {:DOWN, ref, :process, _pid, reason} ->
+        handle_down(queued, ref, reason)
+        wait_for_messages(state)
     end
   end
 
-  defp update_timing(files, pid, key) do
-    Enum.map(files, fn data ->
-      if data.pid == pid do
-        time = System.monotonic_time()
-        %{data | key => data[key] + time - data.timestamp, timestamp: time}
-      else
-        data
-      end
-    end)
-  end
-
-  defp update_timing(data, key) do
-    time = System.monotonic_time()
-    %{data | key => data[key] + time - data.timestamp, timestamp: time}
-  end
-
-  defp maybe_warn_long_compilation(data, state) do
-    compiling = System.convert_time_unit(data.compiling, :native, :millisecond)
-
-    if not data.warned and compiling >= state.long_compilation_threshold do
-      state.each_long_compilation.(data.file)
-      %{data | warned: true}
-    else
-      data
-    end
-  end
-
-  defp discard_and_maybe_log_file(files, pid, state) do
-    Enum.reject(files, fn data ->
-      if data.pid == pid do
-        data = update_timing(data, :compiling)
-        data = maybe_warn_long_compilation(data, state)
-
-        if state.profile != :none do
-          compiling = to_padded_ms(data.compiling)
-          waiting = to_padded_ms(data.waiting)
-          relative = Path.relative_to_cwd(data.file)
-
-          IO.puts(
-            :stderr,
-            "[profile] #{compiling}ms compiling + #{waiting}ms waiting for #{relative}"
-          )
-        end
-
-        true
-      else
-        false
-      end
-    end)
-  end
-
-  defp to_padded_ms(time) do
-    time
-    |> System.convert_time_unit(:native, :millisecond)
-    |> Integer.to_string()
-    |> String.pad_leading(6, " ")
-  end
-
   defp discard_down(pid) do
     receive do
       {:DOWN, _, :process, ^pid, _} -> :ok
     end
   end
 
-  defp handle_down(_files, _ref, :normal) do
+  defp handle_down(_queued, _ref, :normal) do
     :ok
   end
-
-  defp handle_down(files, ref, reason) do
-    case Enum.find(files, &(&1.ref == ref)) do
-      %{pid: pid, file: file} ->
+  defp handle_down(queued, ref, reason) do
+    case List.keyfind(queued, ref, 1) do
+      {_child, ^ref, file, _timer_ref} ->
         print_error(file, :exit, reason, [])
-        files |> Enum.reject(&(&1.pid == pid)) |> terminate()
-        {:error, [to_error(file, :exit, reason, [])]}
-
-      nil ->
+        terminate(queued)
+      _ ->
         :ok
     end
   end
 
-  defp handle_deadlock(waiting, files) do
+  defp handle_deadlock(waiting, queued) do
     deadlock =
-      for %{pid: pid, file: 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)
+        {_kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
+        error = CompileError.exception(description: "deadlocked waiting on module #{inspect on}",
+                                       file: nil, line: nil)
         print_error(file, :error, error, stacktrace)
-        {Path.relative_to_cwd(file), on, description}
+
+        {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: pid} <- files, do: Process.exit(pid, :kill)
-    for %{pid: pid} <- files, do: discard_down(pid)
-    :ok
+  defp terminate(queued) do
+    for {pid, _, _, _} <- queued do
+      Process.exit(pid, :kill)
+    end
+    exit({:shutdown, 1})
   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)
-    ])
+    IO.write ["\n== Compilation error in file #{Path.relative_to_cwd(file)} ==\n",
+             Kernel.CLI.format_error(kind, reason, stack)]
   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 || 0, message}
-  end
-
-  defp get_line(_file, %{line: line, column: column}, _stack)
-       when is_integer(line) and line > 0 and is_integer(column) and column >= 0 do
-    {line, column}
-  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)
+  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.
+        receive do
+          {:timed_out, ^child_pid} -> :ok
+        after
+          0 -> :ok
+        end
+      nil ->
+        :ok
     end
   end
-
-  defp get_line(file, _reason, [{_, _, _, [file: expanding]}, {_, _, _, info} | _])
-       when expanding in ['expanding macro', 'expanding struct'] 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,120 @@
 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)
+
+      result =
+        try do
+          new = Code.require_file(file) || []
+          {:required, Enum.map(new, &elem(&1, 0))}
+        catch
+          kind, reason ->
+            {kind, reason, System.stacktrace}
+        end
+
+      send(parent, {:file_required, self(), file, result})
+      exit(:shutdown)
+    end
+
+    spawn_requires(files, [{pid, ref} | waiting], callbacks, schedulers, result)
+  end
+
+  defp wait_for_messages(files, waiting, callbacks, schedulers, result) do
+    receive do
+      {:file_required, pid, file, {:required, mods}} ->
+        discard_down(pid)
+        if each_file_callback = callbacks[:each_file] do
+          each_file_callback.(file)
+        end
+        waiting = List.keydelete(waiting, pid, 0)
+        spawn_requires(files, waiting, callbacks, schedulers, mods ++ result)
+
+      {:file_required, pid, _file, {kind, reason, stacktrace}} ->
+        discard_down(pid)
+        :erlang.raise(kind, reason, stacktrace)
+
+      {:DOWN, ref, :process, pid, reason} ->
+        handle_down(waiting, pid, ref, reason)
+        spawn_requires(files, waiting, callbacks, schedulers, result)
+
+      {: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
+
+  defp discard_down(pid) do
+    receive do
+      {:DOWN, _, :process, ^pid, _} -> :ok
+    end
+  end
+
+  defp handle_down(waiting, pid, ref, reason) do
+    if reason != :normal and {pid, ref} in waiting do
+      :erlang.raise(:exit, reason, [])
+    end
+    :ok
+  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)
@@ -22,52 +19,16 @@ defmodule Kernel.Utils do
   defp destructure_nil(count), do: [nil | destructure_nil(count - 1)]
 
   @doc """
-  Callback for defdelegate entry point.
+  Callback for defdelegate.
   """
-  def defdelegate_all(funs, opts, env) do
-    to = Keyword.get(opts, :to) || raise ArgumentError, "expected to: to be given as argument"
-    as = Keyword.get(opts, :as)
-
-    if to == env.module and is_nil(as) do
-      raise ArgumentError,
-            "defdelegate function is calling itself, which will lead to an infinite loop. You should either change the value of the :to option or specify the :as option"
-    end
-
-    if is_list(funs) do
-      IO.warn(
-        "passing a list to Kernel.defdelegate/2 is deprecated, please define each delegate separately",
-        Macro.Env.stacktrace(env)
-      )
-    end
-
-    if Keyword.has_key?(opts, :append_first) do
-      IO.warn(
-        "Kernel.defdelegate/2 :append_first option is deprecated",
-        Macro.Env.stacktrace(env)
-      )
-    end
-
-    to
-  end
-
-  @doc """
-  Callback for each function in defdelegate.
-  """
-  def defdelegate_each(fun, opts) when is_list(opts) do
-    # TODO: Remove on v2.0
+  def defdelegate(fun, opts) when is_list(opts) do
+    # TODO: Remove by 2.0
     append_first? = Keyword.get(opts, :append_first, false)
 
     {name, args} =
-      case fun do
-        {:when, _, [_left, right]} ->
-          raise ArgumentError,
-                "guards are not allowed in defdelegate/2, got: when #{Macro.to_string(right)}"
-
-        _ ->
-          case Macro.decompose_call(fun) do
-            {_, _} = pair -> pair
-            _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
-          end
+      case Macro.decompose_call(fun) do
+        {_, _} = pair -> pair
+        _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
       end
 
     as = Keyword.get(opts, :as, name)
@@ -93,160 +54,55 @@ defmodule Kernel.Utils do
   end
 
   defp validate_arg(ast) do
-    raise ArgumentError,
-          "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
+    raise ArgumentError, "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
   end
 
   @doc """
   Callback for defstruct.
   """
-  def defstruct(module, fields, bootstrapped?) do
-    {set, bag} = :elixir_module.data_tables(module)
-
-    if :ets.member(set, :__struct__) do
-      raise ArgumentError,
-            "defstruct has already been called for " <>
-              "#{Kernel.inspect(module)}, defstruct can only be called once per module"
-    end
-
+  def defstruct(module, fields) 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
-          :elixir_quote.escape(val, false, :none)
+          Macro.escape(val)
         rescue
           e in [ArgumentError] ->
             raise ArgumentError, "invalid value for struct field #{key}, " <> Exception.message(e)
         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))
 
-    enforce_keys =
-      case :ets.lookup(set, :enforce_keys) do
-        [{_, enforce_keys, _, _}] when is_list(enforce_keys) ->
-          :ets.update_element(set, :enforce_keys, {3, :used})
-          enforce_keys
+    :lists.foreach(fn
+      key when is_atom(key) -> :ok
+      key -> raise ArgumentError, "keys given to @enforce_keys must be atoms, got: #{inspect key}"
+    end, enforce_keys)
 
-        [{_, enforce_key, _, _}] ->
-          :ets.update_element(set, :enforce_keys, {3, :used})
-          [enforce_key]
-
-        [] ->
-          []
-      end
-
-    # 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))
-
-    body =
-      case bootstrapped? do
-        true ->
-          case enforce_keys do
-            [] ->
-              quote do
-                Enum.reduce(kv, @__struct__, fn {key, val}, map ->
-                  %{map | key => val}
-                end)
-              end
-
-            _ ->
-              quote do
-                {map, keys} =
-                  Enum.reduce(kv, {@__struct__, unquote(enforce_keys)}, fn
-                    {key, val}, {map, keys} ->
-                      {%{map | key => val}, List.delete(keys, key)}
-                  end)
-
-                case keys do
-                  [] ->
-                    map
-
-                  _ ->
-                    raise ArgumentError,
-                          "the following keys must also be given when building " <>
-                            "struct #{inspect(__MODULE__)}: #{inspect(keys)}"
-                end
-              end
-          end
-
-        false ->
-          quote do
-            :lists.foldl(
-              fn {key, val}, acc -> %{acc | key => val} end,
-              @__struct__,
-              kv
-            )
-          end
-      end
-
-    case enforce_keys -- :maps.keys(struct) do
-      [] ->
-        # The __struct__ field is used for expansion and for loading remote structs
-        :ets.insert(set, {:__struct__, struct, nil, []})
-
-        # Store all field metadata to go into __info__(:struct)
-        mapper = fn {key, val} ->
-          %{field: key, default: val, required: :lists.member(key, enforce_keys)}
-        end
-
-        :ets.insert(set, {{:elixir, :struct}, :lists.map(mapper, fields)})
-        derive = :lists.map(fn {_, value} -> value end, :ets.take(bag, {:accumulate, :derive}))
-        {struct, :lists.reverse(derive), quote(do: kv), body}
-
-      error_keys ->
-        raise ArgumentError,
-              "@enforce_keys required keys (#{inspect(error_keys)}) that are not defined in defstruct: " <>
-                "#{inspect(fields)}"
-    end
-  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)),
+     enforce_keys,
+     Module.get_attribute(module, :derive)}
   end
 
   @doc """
   Announcing callback for defstruct.
   """
   def announce_struct(module) do
-    case :erlang.get(:elixir_compiler_info) do
+    case :erlang.get(:elixir_compiler_pid) do
       :undefined -> :ok
-      {pid, _} -> send(pid, {:available, :struct, module})
+      pid -> send(pid, {:struct_available, module})
     end
   end
 
@@ -256,158 +112,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, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), 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, env.module)))
-      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, module) 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) + 1))
-                  new_var = Macro.unique_var(generated, module)
-                  {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 a module name, string or exception as " <>
+                            "the first argument, got: #{inspect other}")
   end
 end