Release v1.0.0-rc1

Document that @compile accumulates.

.formatter.exs

@@ -1,25 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-[
-  inputs: [
-    "lib/*/{lib,scripts,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,
-
-    # Float tests
-    float_assert: 1
-  ]
-]

.gitattributes

@@ -1,7 +1 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 lib/elixir/test/elixir/fixtures/*.txt text eol=lf
-*.ex diff=elixir
-*.exs diff=elixir

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
----
-blank_issues_enabled: true
-
-contact_links:
-  - name: Ask questions, support, and general discussions
-    url: https://elixirforum.com/
-    about: Ask questions, provide support, and more on Elixir Forum
-
-  - name: Propose new features
-    url: https://github.com/elixir-lang/elixir/#proposing-new-features
-    about: Propose new features in our mailing list

.github/ISSUE_TEMPLATE/issue.yml

@@ -1,61 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
----
-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) or any of
-        our online communities (Slack, Discord, etc).
-
-  - type: checkboxes
-    id: existing-issue
-    attributes:
-      label: Existing issue
-      description: Please search [existing issues](https://github.com/elixir-lang/elixir/issues) before continuing.
-      options:
-        - label: I have searched existing issues and could not find a duplicate.
-          required: true
-
-  - 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,11 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    cooldown:
-      default-days: 7

.github/pull_request_template.md

@@ -1,4 +0,0 @@
-* Describe here the reasons behind the pull request.
-* Make sure you have read the CONTRIBUTING.md file.
-* Make sure any relevant documentation and tests have been added/updated.
-* Do not submit Draft pull requests unless previously asked/agreed.

.github/workflows/ci.yml

@@ -1,151 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-name: CI
-
-on:
-  push:
-  pull_request:
-  workflow_dispatch:
-
-env:
-  ELIXIR_ASSERT_TIMEOUT: 2000
-  ELIXIRC_OPTS: "--warnings-as-errors"
-  LANG: C.UTF-8
-
-permissions:
-  contents: read
-
-jobs:
-  test_linux:
-    name: Ubuntu 24.04, OTP ${{ matrix.otp_version }}${{ matrix.deterministic && ' (deterministic)' || '' }}${{ matrix.coverage && ' (coverage)' || '' }}
-    runs-on: ubuntu-24.04
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - otp_version: "29.0"
-            deterministic: true
-          - otp_version: "28.4"
-            docs: true
-            coverage: true
-          - otp_version: "28.1"
-          - otp_version: "27.3"
-          - otp_version: "27.0"
-          - otp_version: master
-            development: true
-          - otp_version: maint
-            development: true
-
-    env:
-      ERLC_OPTS: "warnings_as_errors"
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - uses: erlef/setup-beam@54075bcc5e249e4758d363f27d099f55d843f124 # v1.24.1
-        with:
-          otp-version: ${{ matrix.otp_version }}
-
-      - name: Set ERL_COMPILER_OPTIONS
-        if: ${{ matrix.deterministic }}
-        run: echo "ERL_COMPILER_OPTIONS=deterministic" >> $GITHUB_ENV
-
-      - name: Compile Elixir
-        run: |
-          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: Erlang test suite
-        run: make test_erlang
-        continue-on-error: ${{ matrix.development == true }}
-
-      - name: Elixir test suite
-        run: make test_elixir
-        continue-on-error: ${{ matrix.development == true }}
-        env:
-          COVER: "${{ matrix.coverage }}"
-
-      - name: Build docs (ExDoc main)
-        if: ${{ matrix.docs }}
-        run: |
-          cd ..
-          git clone https://github.com/elixir-lang/ex_doc.git --depth 1
-          cd ex_doc
-          ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile
-          cd ../elixir/
-          git fetch --tags
-          DOCS_OPTIONS="--warnings-as-errors" make docs
-
-      - name: "Calculate Coverage"
-        if: ${{ matrix.coverage }}
-        run: make cover | tee "$GITHUB_STEP_SUMMARY"
-
-      - name: "Upload Coverage Artifact"
-        if: ${{ matrix.coverage }}
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: TestCoverage
-          path: cover/*
-
-      - name: Check reproducible builds
-        if: ${{ matrix.deterministic }}
-        run: taskset 1 make check_reproducible
-
-      - name: Check git is not required
-        if: ${{ matrix.deterministic }}
-        run: |
-          rm -rf .git
-          cd lib/elixir
-          elixirc --ignore-module-conflict -o ebin "lib/**/*.ex"
-
-  test_windows:
-    name: Windows Server 2022, OTP ${{ matrix.otp_version }}
-    runs-on: windows-2022
-
-    strategy:
-      matrix:
-        otp_version:
-          - "29.0"
-          - "28.1"
-          - "27.3"
-
-    steps:
-      - name: Configure Git
-        run: git config --global core.autocrlf input
-
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - uses: erlef/setup-beam@54075bcc5e249e4758d363f27d099f55d843f124 # v1.24.1
-        with:
-          otp-version: ${{ matrix.otp_version }}
-
-      - name: Compile Elixir
-        run: |
-          Remove-Item -Recurse -Force '.git'
-          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 test_erlang
-
-      - name: Elixir test suite
-        run: |
-          Remove-Item 'c:/Windows/System32/drivers/etc/hosts'
-          make test_elixir

.github/workflows/codeql.yml

@@ -1,55 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2026 The Elixir Team
-
-name: "CodeQL Advanced"
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-  schedule:
-    - cron: "29 8 * * 1"
-
-permissions:
-  contents: read
-
-jobs:
-  analyze:
-    name: Analyze (${{ matrix.language }})
-    runs-on: "ubuntu-latest"
-    permissions:
-      security-events: write
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - language: actions
-            build-mode: none
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
-        with:
-          languages: ${{ matrix.language }}
-          build-mode: ${{ matrix.build-mode }}
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
-        with:
-          category: "/language:${{matrix.language}}"
-
-  zizmor:
-    name: Zizmor
-    runs-on: ubuntu-latest
-    permissions:
-      security-events: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Run zizmor
-        uses: zizmorcore/zizmor-action@3dc1ecc9bcb9e94e9b2c709687979e1298497054 # v0.6.2

.github/workflows/license_compliance.yml

@@ -1,41 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-name: License Compliance
-
-on:
-  push:
-  pull_request:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-env:
-  LANG: C.UTF-8
-
-jobs:
-  license_compliance:
-    name: Check License Compliance
-    runs-on: ubuntu-24.04
-
-    steps:
-      - name: Use HTTPS instead of SSH for Git cloning
-        id: git-config
-        shell: bash
-        run: git config --global url.https://github.com/.insteadOf ssh://git@github.com/
-
-      - name: Checkout project
-        id: checkout
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - name: Run OSS Review Toolkit
-        id: ort
-        uses: ./.github/workflows/ort
-        with:
-          upload-reports: true
-          fail-on-violation: true
-          report-formats: "WebApp"
-          version: "${{ github.sha }}"

.github/workflows/markdown.yml

@@ -1,41 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-name: Markdown Content
-
-on:
-  push:
-    branches:
-      - "main"
-
-    paths: &paths-filter
-      - "**/*.md"
-      - .github/workflows/markdown.yml
-      - .markdownlint-cli2.jsonc
-
-  pull_request:
-    paths: *paths-filter
-
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-env:
-  LANG: C.UTF-8
-
-jobs:
-  lint:
-    name: Lint Markdown content
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - name: Run markdownlint-cli2
-        uses: DavidAnson/markdownlint-cli2-action@21c1be1b93ad9ed58fa840aacc3f279cde2a72ff # v24.2.0

.github/workflows/notify.exs

@@ -1,79 +0,0 @@
-# #!/usr/bin/env elixir
-
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-[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
-
-body = "https://github.com/elixir-lang/elixir/releases/tag/#{tag}\n\n#{line_items}"
-
-IO.puts([
-  "========================================\n",
-  body,
-  "\n========================================"
-])
-
-mail = %{
-  # The email must have access to post
-  "From" => "jose.valim@dashbit.co",
-  "To" => "elixir-lang-ann@googlegroups.com",
-  "Subject" => "Elixir #{tag} released",
-  "HtmlBody" => body,
-  "MessageStream" => "outbound"
-}
-
-unless System.get_env("DRYRUN") do
-  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
-}
-
-unless System.get_env("DRYRUN") do
-  headers = %{
-    "api-key" => System.fetch_env!("ELIXIR_FORUM_TOKEN"),
-    "api-username" => "Elixir"
-  }
-
-  resp = Req.post!("https://forum.elixirforum.com/posts.json", {:json, post}, headers: headers)
-  IO.puts("#{resp.status} Elixir Forum\n#{inspect(resp.body)}")
-end

.github/workflows/ort/action.yml

@@ -1,112 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-name: "Run OSS Review Toolkit"
-description: "Runs OSS Review Toolkit & generates SBoMs"
-inputs:
-  report-formats:
-    description: "ORT Report Formats"
-    required: true
-  fail-on-violation:
-    description: "Whether to fail on violation."
-    required: false
-    default: false
-  upload-reports:
-    description: "Whether to upload all reports"
-    required: false
-    default: false
-  version:
-    description: "Elixir Version (Tag / SHA)"
-    required: true
-
-outputs:
-  results-path:
-    description: "See oss-review-toolkit/ort-ci-github-action action"
-    value: "${{ steps.ort.outputs.results-path }}"
-  results-sbom-cyclonedx-xml-path:
-    description: "See oss-review-toolkit/ort-ci-github-action action"
-    value: "${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}"
-  results-sbom-cyclonedx-json-path:
-    description: "See oss-review-toolkit/ort-ci-github-action action"
-    value: "${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}"
-  results-sbom-spdx-yml-path:
-    description: "See oss-review-toolkit/ort-ci-github-action action"
-    value: "${{ steps.ort.outputs.results-sbom-spdx-yml-path }}"
-  results-sbom-spdx-json-path:
-    description: "See oss-review-toolkit/ort-ci-github-action action"
-    value: "${{ steps.ort.outputs.results-sbom-spdx-json-path }}"
-
-runs:
-  using: "composite"
-  steps:
-    - name: Fetch Default ORT Config
-      id: fetch-default-ort-config
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      with:
-        repository: oss-review-toolkit/ort-config
-        ref: "main"
-        path: ".ort-config"
-        persist-credentials: false
-
-    - name: Setup ORT Config
-      id: setup-ort-config
-      shell: bash
-      run: |
-        mkdir -p "/$HOME/.ort/"
-
-        # Move Fetched Default Config into Place
-        mv .ort-config "$HOME/.ort/config"
-        
-        # Append Global ORT Config
-        cat .ort/config/config.yml >> "$HOME/.ort/config/config.yml"
-        
-        # Override Default Evaluator Rules
-        cp .ort/config/evaluator.rules.kts "$HOME/.ort/config/evaluator.rules.kts"
-
-        # Add Package Configurations
-        mkdir -p "$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team"
-        for FILE in .ort/package-configurations/*.yml; do
-          COMPONENT="$(basename "$FILE")"
-          cp "$FILE" "$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team/$COMPONENT"
-          sed -i -E \
-            "s/(\"SpdxDocumentFile:The Elixir Team:.+:)\"/\1${ELIXIR_VERSION}\"/" \
-            "$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team/$COMPONENT"
-        done
-
-        # Set Version in SPDX & Config
-        sed -i "s/# elixir-version-insert/versionInfo: '${ELIXIR_VERSION}'/" project.spdx.yml
-        sed -i -E "s/(\"SpdxDocumentFile:The Elixir Team:.+:)\"/\1${ELIXIR_VERSION}\"/" .ort.yml
-        sed -i "s|https://github.com/elixir-lang/elixir.git|${ELIXIR_REPO}@${ELIXIR_VERSION}|" project.spdx.yml
-      env:
-        ELIXIR_VERSION: "${{ inputs.version }}"
-        ELIXIR_REPO: "${{ github.server_url }}/${{ github.repository }}.git"
-
-    - name: "Cache ScanCode"
-      uses: actions/cache@d4323d4df104b026a6aa633fdb11d772146be0bf # v4.2.2
-      with:
-        path: "~/.cache/scancode-tk"
-        key: ${{ runner.os }}-scancode
-
-    - name: Run OSS Review Toolkit
-      id: ort
-      uses: oss-review-toolkit/ort-ci-github-action@086d928d24ef1653dc0777296b312fda5faaaf52 # v1.2.0
-      with:
-        image: ghcr.io/oss-review-toolkit/ort:92.2.0
-        run: >-
-          labels,
-          cache-dependencies,
-          cache-scan-results,
-          analyzer,
-          scanner,
-          advisor,
-          evaluator,
-          reporter,
-          ${{ inputs.upload-reports == 'true' && 'upload-results' || '' }}
-        fail-on: "${{ inputs.fail-on-violation == 'true' && 'violations,issues' || '' }}"
-        report-formats: "${{ inputs.report-formats }}"
-        ort-cli-report-args: >-
-          -O CycloneDX=output.file.formats=json,xml
-          -O SpdxDocument=outputFileFormats=JSON,YAML
-        ort-cli-scan-args: >-
-          --scanners Provenant
-        sw-version: "${{ inputs.version }}"

.github/workflows/posix_compliance.yml

@@ -1,53 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-name: POSIX Compliance
-
-on:
-  push:
-    paths: &paths-filter
-      - .github/workflows/posix_compliance.yml
-      - bin/elixir
-      - bin/elixirc
-      - bin/iex
-
-  pull_request:
-    paths: *paths-filter
-
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-env:
-  LANG: C.UTF-8
-
-jobs:
-  check_posix_compliance:
-    name: Check POSIX compliance
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - name: Install ShellCheck
-        run: |
-          sudo apt update
-          sudo apt install -y shellcheck
-
-      - name: Run ShellCheck on bin/ dir
-        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/release.yml

@@ -1,446 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-name: Releases
-
-on:
-  push:
-    branches:
-      - main
-      - v*.*
-
-    tags:
-      - v*
-
-  workflow_dispatch:
-
-env:
-  ELIXIR_OPTS: "--warnings-as-errors"
-  LANG: C.UTF-8
-
-permissions:
-  contents: read
-
-jobs:
-  create_draft_release:
-    name: Create draft release
-    runs-on: ubuntu-24.04
-
-    permissions:
-      contents: write
-
-    env:
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-    steps:
-      - name: Create draft release
-        if: github.ref_type != 'branch'
-        run: |
-          gh release create \
-            --repo "$GITHUB_REPOSITORY" \
-            --title "$GITHUB_REF_NAME" \
-            --notes '' \
-            --draft \
-            "$GITHUB_REF_NAME"
-
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        # zizmor: ignore[artipacked]
-        if: github.ref_type == 'branch'
-
-      - name: Update ${{ github.ref_name }}-latest
-        if: github.ref_type == 'branch'
-        run: |
-          ref_name="${GITHUB_REF_NAME}-latest"
-
-          if ! gh release view "$ref_name"; then
-            gh release create \
-              --latest=false \
-              --title "$ref_name" \
-              --notes "Automated release for latest ${GITHUB_REF_NAME}." \
-              "$ref_name"
-          fi
-
-          git tag "$ref_name" --force
-          git push origin "$ref_name" --force
-
-  build:
-    name: Ubuntu 24.04, OTP ${{ matrix.otp_version }}${{ matrix.build_docs && ' (build docs)' || '' }}
-    runs-on: ubuntu-24.04
-
-    strategy:
-      fail-fast: true
-      matrix:
-        include:
-          - otp: 27
-            otp_version: "27.0"
-
-          - otp: 28
-            otp_version: "28.0"
-            build_docs: build_docs
-
-          - otp: 29
-            otp_version: "29.0"
-
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - name: "Build Release"
-        uses: ./.github/workflows/release_pre_built
-        with:
-          otp_version: ${{ matrix.otp_version }}
-          otp: ${{ matrix.otp }}
-          build_docs: ${{ matrix.build_docs }}
-
-      - name: Create Docs Hashes
-        if: matrix.build_docs
-        run: |
-          shasum -a 1   Docs.zip > Docs.zip.sha1sum
-          shasum -a 256 Docs.zip > Docs.zip.sha256sum
-
-      - name: "Upload Linux release artifacts"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: build-linux-elixir-otp-${{ matrix.otp }}
-          path: elixir-otp-${{ matrix.otp }}.zip
-
-      - name: "Upload Windows release artifacts"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: build-windows-elixir-otp-${{ matrix.otp }}
-          path: elixir-otp-${{ matrix.otp }}.exe
-
-      - name: "Upload doc artifacts"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        if: matrix.build_docs
-        with:
-          name: Docs
-          path: Docs.zip*
-
-  sign:
-    name: Sign files, ${{ matrix.flavor == 'windows' && 'Windows' || matrix.flavor == 'linux' && 'Linux' || matrix.flavor }}, OTP ${{ matrix.otp }}
-    needs: [build]
-    environment: release
-    strategy:
-      fail-fast: true
-      matrix:
-        otp: [27, 28, 29]
-        flavor: [windows, linux]
-
-    env:
-      RELEASE_FILE: elixir-otp-${{ matrix.otp }}.${{ matrix.flavor == 'linux' && 'zip' || 'exe' }}
-
-    runs-on: ${{ matrix.flavor == 'linux' && 'ubuntu-24.04' || 'windows-2022' }}
-
-    permissions:
-      contents: write
-      id-token: write
-
-    steps:
-      - name: "Download build"
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          name: build-${{ matrix.flavor }}-elixir-otp-${{ matrix.otp }}
-
-      - name: Log in to Azure
-        if: ${{ matrix.flavor == 'windows' && vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-        uses: azure/login@f5d393ae46f8fde4be8b75f32e3fc50e654ad0ca # v3.0.1
-        with:
-          client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-
-      - name: "Sign files with Trusted Signing"
-        uses: azure/trusted-signing-action@c7ab2a863ab5f9a846ddb8265964877ef296ee82 # v2.0.0
-        if: ${{ matrix.flavor == 'windows' && vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-        with:
-          endpoint: https://eus.codesigning.azure.net/
-          trusted-signing-account-name: ${{ vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-          certificate-profile-name: ${{ vars.AZURE_CERTIFICATE_PROFILE_NAME }}
-          files-folder: ${{ github.workspace }}
-          files-folder-filter: exe
-          file-digest: SHA256
-          timestamp-rfc3161: http://timestamp.acs.microsoft.com
-          timestamp-digest: SHA256
-
-      - name: Create Release Hashes
-        if: matrix.flavor == 'windows'
-        shell: pwsh
-        run: |
-          $sha1 = Get-FileHash "$env:RELEASE_FILE" -Algorithm SHA1
-          $sha1.Hash.ToLower() + "  " + $env:RELEASE_FILE | Out-File "$env:RELEASE_FILE.sha1sum"
-
-          $sha256 = Get-FileHash "$env:RELEASE_FILE" -Algorithm SHA256
-          $sha256.Hash.ToLower() + "  " + $env:RELEASE_FILE | Out-File "$env:RELEASE_FILE.sha256sum"
-
-      - name: Create Release Hashes
-        if: matrix.flavor == 'linux'
-        shell: bash
-        run: |
-          shasum -a 1   "$RELEASE_FILE" > "${RELEASE_FILE}.sha1sum"
-          shasum -a 256 "$RELEASE_FILE" > "${RELEASE_FILE}.sha256sum"
-
-      - name: "Upload Linux release artifacts"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: sign-${{ matrix.flavor }}-elixir-otp-${{ matrix.otp }}
-          path: ${{ env.RELEASE_FILE }}*
-
-  sbom:
-    name: Generate SBoM
-    needs: [build, sign]
-    runs-on: ubuntu-24.04
-
-    permissions:
-      contents: write
-      id-token: write
-      attestations: write
-
-    steps:
-      - name: Use HTTPS instead of SSH for Git cloning
-        id: git-config
-        shell: bash
-        run: git config --global url.https://github.com/.insteadOf ssh://git@github.com/
-
-      - name: Checkout project
-        id: checkout
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - name: "Download Build Artifacts"
-        id: download-build-artifacts
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          pattern: "{sign-*-elixir-otp-*,Docs}"
-          merge-multiple: true
-          path: /tmp/build-artifacts/
-
-      - name: "Run OSS Review Toolkit"
-        id: ort
-        uses: ./.github/workflows/ort
-        with:
-          report-formats: "CycloneDx,SpdxDocument"
-          version: "${{ github.ref_type	== 'tag' && github.ref_name || github.sha }}"
-
-      - name: Attest Distribution Assets with SBoM
-        id: attest-sbom
-        uses: actions/attest-sbom@c604332985a26aa8cf1bdc465b92731239ec6b9e # v4.1.0
-        with:
-          subject-path: |
-            /tmp/build-artifacts/{elixir-otp-*.*,Docs.zip}
-            ${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}
-            ${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}
-            ${{ steps.ort.outputs.results-sbom-spdx-yml-path }}
-            ${{ steps.ort.outputs.results-sbom-spdx-json-path }}
-          sbom-path: "${{ steps.ort.outputs.results-sbom-spdx-json-path }}"
-
-      - name: "Copy SBoM provenance"
-        id: sbom-provenance
-        shell: bash
-        run: |
-          mkdir attestations
-
-          for FILE in /tmp/build-artifacts/{elixir-otp-*.*,Docs.zip}; do
-            cp "$ATTESTATION" "attestations/$(basename "$FILE").sigstore"
-          done
-
-          cp "$ATTESTATION" "attestations/$(basename "$SBOM_CYCLONEDX_XML").sigstore"
-          cp "$ATTESTATION" "attestations/$(basename "$SBOM_CYCLONEDX_JSON").sigstore"
-          cp "$ATTESTATION" "attestations/$(basename "$SBOM_SPDX_YML").sigstore"
-          cp "$ATTESTATION" "attestations/$(basename "$SBOM_SPDX_JSON").sigstore"
-        env:
-          ATTESTATION: "${{ steps.attest-sbom.outputs.bundle-path }}"
-          SBOM_CYCLONEDX_XML: "${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}"
-          SBOM_CYCLONEDX_JSON: "${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}"
-          SBOM_SPDX_YML: "${{ steps.ort.outputs.results-sbom-spdx-yml-path }}"
-          SBOM_SPDX_JSON: "${{ steps.ort.outputs.results-sbom-spdx-json-path }}"
-
-      - name: "Assemble Release SBoM Artifacts"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: "SBoM"
-          path: |
-            ${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}
-            ${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}
-            ${{ steps.ort.outputs.results-sbom-spdx-yml-path }}
-            ${{ steps.ort.outputs.results-sbom-spdx-json-path }}
-
-      - name: "Assemble Distribution Attestations"
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: "Attestations"
-          path: "attestations/*.sigstore"
-
-  upload-release:
-    name: Upload release
-    needs: [create_draft_release, build, sign, sbom]
-    runs-on: ubuntu-24.04
-
-    permissions:
-      contents: write
-
-    steps:
-      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          pattern: "{sign-*-elixir-otp-*,Docs,SBoM,Attestations}"
-          merge-multiple: true
-
-      - name: Upload Pre-build
-        shell: bash
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          if [ "$GITHUB_REF_TYPE" == "branch" ]; then
-            tag="${GITHUB_REF_NAME}-latest"
-          else
-            tag="$GITHUB_REF_NAME"
-          fi
-
-          gh release upload \
-            --repo "$GITHUB_REPOSITORY" \
-            --clobber \
-            "$tag" \
-            elixir-otp-*.zip \
-            elixir-otp-*.zip.sha{1,256}sum \
-            elixir-otp-*.zip.sigstore \
-            elixir-otp-*.exe \
-            elixir-otp-*.exe.sha{1,256}sum \
-            elixir-otp-*.exe.sigstore \
-            Docs.zip \
-            Docs.zip.sha{1,256}sum \
-            Docs.zip.sigstore \
-            bom.*
-
-  upload-builds-hex-pm:
-    name: Upload builds to hex.pm
-    runs-on: ubuntu-24.04
-    needs: [build, sign]
-    concurrency: builds-hex-pm
-    environment: release
-
-    env:
-      AWS_ACCESS_KEY_ID: ${{ secrets.HEX_AWS_ACCESS_KEY_ID }}
-      AWS_SECRET_ACCESS_KEY: ${{ secrets.HEX_AWS_SECRET_ACCESS_KEY }}
-      AWS_REGION: ${{ vars.HEX_AWS_REGION }}
-      AWS_S3_BUCKET: ${{ vars.HEX_AWS_S3_BUCKET }}
-
-    steps:
-      - name: "Check if variables are set up"
-        if: "${{ ! vars.HEX_AWS_REGION }}"
-        run: |
-          echo "Required variables for uploading to hex.pm are not set up, skipping..."
-          exit 1
-
-      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-        with:
-          pattern: "{sign-*-elixir-otp-*,Docs}"
-          merge-multiple: true
-
-      - name: Init purge keys file
-        run: |
-          touch purge_keys.txt
-
-      - name: Upload Precompiled to S3
-        run: |
-          oldest_otp=$(find . -type f -name 'elixir-otp-*.zip' | sed -r 's/^.*elixir-otp-([[:digit:]]+)\.zip$/\1/' | sort -n | head -n 1)
-
-          for zip in $(find . -type f -name 'elixir-otp-*.zip' | sed 's/^\.\///'); do
-            dest=${zip/elixir/${GITHUB_REF_NAME}}
-            surrogate_key=${dest/.zip$/}
-
-            aws s3 cp "${zip}" "s3://${AWS_S3_BUCKET}/builds/elixir/${dest}" \
-              --cache-control "public,max-age=3600" \
-              --metadata "{\"surrogate-key\":\"builds builds/elixir builds/elixir/${surrogate_key}\",\"surrogate-control\":\"public,max-age=604800\"}"
-            echo "builds/elixir/${surrogate_key}" >> purge_keys.txt
-
-            if [ "$zip" == "elixir-otp-${oldest_otp}.zip" ]; then
-              aws s3 cp "${zip}" "s3://${AWS_S3_BUCKET}/builds/elixir/${GITHUB_REF_NAME}.zip" \
-                --cache-control "public,max-age=3600" \
-                --metadata "{\"surrogate-key\":\"builds builds/elixir builds/elixir/${GITHUB_REF_NAME}\",\"surrogate-control\":\"public,max-age=604800\"}"
-              echo builds/elixir/${GITHUB_REF_NAME} >> purge_keys.txt
-            fi
-          done
-
-      - name: Upload Docs to S3
-        run: |
-          version=$(echo "$GITHUB_REF_NAME" | sed -e 's/^v//g')
-
-          unzip Docs.zip
-
-          for f in doc/*; do
-            if [ -d "$f" ]; then
-              app=$(echo "$f" | sed s/"doc\/"//)
-              tarball="${app}-${version}.tar.gz"
-              surrogate_key="docs/${app}-${version}"
-
-              tar -czf "${tarball}" -C "doc/${app}" .
-              aws s3 cp "${tarball}" "s3://${AWS_S3_BUCKET}/docs/${tarball}" \
-                --cache-control "public,max-age=3600" \
-                --metadata "{\"surrogate-key\":\"${surrogate_key}\",\"surrogate-control\":\"public,max-age=604800\"}"
-              echo "${surrogate_key}" >> ../purge_keys.txt
-            fi
-          done
-
-      - name: Update builds txt
-        run: |
-          date="$(date -u '+%Y-%m-%dT%H:%M:%SZ')"
-          ref_name="$GITHUB_REF_NAME"
-
-          oldest_otp=$(find . -name 'elixir-otp-*.zip.sha256sum' | sed -r 's/^.*elixir-otp-([[:digit:]]+)\.zip\.sha256sum$/\1/' | sort -n | head -n 1)
-
-          aws s3 cp "s3://${AWS_S3_BUCKET}/builds/elixir/builds.txt" builds.txt || true
-          touch builds.txt
-
-          for sha256_file in $(find . -name 'elixir-otp-*.zip.sha256sum' | sed 's/^\.\///'); do
-            otp_version=$(echo "${sha256_file}" | sed -r 's/^elixir-otp-([[:digit:]]+)\.zip\.sha256sum/otp-\1/')
-            build_sha256=$(cut -d ' ' -f 1 "${sha256_file}")
-
-            sed -i "/^${ref_name}-${otp_version} /d" builds.txt
-            echo -e "${ref_name}-${otp_version} ${{ github.sha }} ${date} ${build_sha256} \n$(cat builds.txt)" > builds.txt
-
-            if [ "${otp_version}" == "otp-${oldest_otp}" ]; then
-              sed -i "/^${ref_name} /d" builds.txt
-              echo -e "${ref_name} ${{ github.sha }} ${date} ${build_sha256} \n$(cat builds.txt)" > builds.txt
-            fi
-          done
-
-          sort -u -k1,1 -o builds.txt builds.txt
-          aws s3 cp builds.txt "s3://${AWS_S3_BUCKET}/builds/elixir/builds.txt" \
-            --cache-control "public,max-age=3600" \
-            --metadata '{"surrogate-key":"builds builds/elixir builds/elixir/txt","surrogate-control":"public,max-age=604800"}'
-
-          echo 'builds/elixir/txt' >> purge_keys.txt
-
-      - name: Flush cache
-        if: github.repository == 'elixir-lang/elixir'
-        run: |
-          function purge_key() {
-            curl \
-               -X POST \
-               -H "Fastly-Key: ${FASTLY_KEY}" \
-               -H "Accept: application/json" \
-               -H "Content-Length: 0" \
-               "https://api.fastly.com/service/$1/purge/$2"
-          }
-
-          function purge() {
-            purge_key ${FASTLY_REPO_SERVICE_ID} $1
-            purge_key ${FASTLY_BUILDS_SERVICE_ID} $1
-            sleep 2
-            purge_key ${FASTLY_REPO_SERVICE_ID} $1
-            purge_key ${FASTLY_BUILDS_SERVICE_ID} $1
-            sleep 2
-            purge_key ${FASTLY_REPO_SERVICE_ID} $1
-            purge_key ${FASTLY_BUILDS_SERVICE_ID} $1
-          }
-
-          for key in $(cat purge_keys.txt); do
-            purge "${key}"
-          done
-
-        env:
-          FASTLY_REPO_SERVICE_ID: ${{ secrets.HEX_FASTLY_REPO_SERVICE_ID }}
-          FASTLY_BUILDS_SERVICE_ID: ${{ secrets.HEX_FASTLY_BUILDS_SERVICE_ID }}
-          FASTLY_KEY: ${{ secrets.HEX_FASTLY_KEY }}

.github/workflows/release_notifications.yml

@@ -1,34 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-name: Release Notifications
-
-on:
-  release:
-    types:
-      - published
-
-permissions:
-  contents: read
-
-jobs:
-  notify:
-    runs-on: ubuntu-latest
-    name: Notify
-
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - uses: erlef/setup-beam@54075bcc5e249e4758d363f27d099f55d843f124 # v1.24.1
-        with:
-          otp-version: "27.3"
-          elixir-version: "1.18.3"
-
-      - 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_pre_built/action.yml

@@ -1,81 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-name: Release Pre-build
-description: "Builds Elixir release, ExDoc and generates docs"
-
-inputs:
-  otp:
-    description: "The major OTP version"
-
-  otp_version:
-    description: "The exact OTP version (major.minor[.patch])"
-
-  build_docs:
-    description: "Whether docs have to be built"
-
-runs:
-  using: "composite"
-
-  steps:
-    - uses: erlef/setup-beam@5304e04ea2b355f03681464e683d92e3b2f18451 # v1.18.2
-      with:
-        otp-version: ${{ inputs.otp_version }}
-        version-type: strict
-
-    - name: Build Elixir Release
-      shell: bash
-      run: | # zizmor: ignore[github-env]
-        make Precompiled.zip
-        mv Precompiled.zip "elixir-otp-${INPUT_OTP}.zip"
-        echo "$PWD/bin" >> $GITHUB_PATH
-      env:
-        INPUT_OTP: ${{ inputs.otp }}
-
-    - name: Install NSIS
-      shell: bash
-      run: |
-        sudo apt update
-        sudo apt install -y nsis
-
-    - name: Build Elixir Windows Installer
-      shell: bash
-      run: |
-        export OTP_VERSION="$INPUT_OTP_VERSION"
-        export ELIXIR_ZIP="$PWD/elixir-otp-${INPUT_OTP}.zip"
-        (cd lib/elixir/scripts/windows_installer && ./build.sh)
-        mv "lib/elixir/scripts/windows_installer/tmp/elixir-otp-${INPUT_OTP}.exe" .
-      env:
-        INPUT_OTP: ${{ inputs.otp }}
-        INPUT_OTP_VERSION: ${{ inputs.otp_version }}
-    - name: Get ExDoc ref
-      if: ${{ inputs.build_docs }}
-      shell: bash
-      run: | # zizmor: ignore[github-env]
-        if [ "$GITHUB_REF_NAME" = "main" ]; then
-          ref=main
-        else
-          ref=v$(curl -s https://hex.pm/api/packages/ex_doc | jq --raw-output '.latest_stable_version')
-        fi
-        echo "EX_DOC_REF=$ref" >> $GITHUB_ENV
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-      if: ${{ inputs.build_docs }}
-      with:
-        repository: elixir-lang/ex_doc
-        ref: ${{ env.EX_DOC_REF }}
-        path: ex_doc
-        persist-credentials: false
-    - name: Build ex_doc
-      if: ${{ inputs.build_docs }}
-      shell: bash
-      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: ${{ inputs.build_docs }}
-      shell: bash
-      run: |
-        git fetch --tags
-        make Docs.zip

.gitignore

@@ -1,19 +1,13 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-/doc/
-/lib/*/ebin/
-/lib/*/_build/
-/lib/*/tmp/
-/lib/elixir/src/*_parser.erl
-/lib/elixir/test/ebin/
-/man/elixir.1
-/man/iex.1
-/Docs.zip
-/Precompiled.zip
 /.eunit
-.elixir.plt
+/.release
+/docs
+/ebin
+/lib/*/ebin/*
+/lib/*/tmp
+/lib/elixir/src/elixir.app.src
+/lib/elixir/src/*_lexer.erl
+/lib/elixir/src/*_parser.erl
+/lib/elixir/test/ebin
+/rel/elixir
 erl_crash.dump
-/cover/
-.tool-versions
+.elixir.plt

.markdownlint-cli2.jsonc

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: 2021 The Elixir Team
-{
-  "globs": [
-    "**/*.md"
-  ],
-  "ignores": [
-    ".git/**",
-    ".github/**"
-  ],
-  "gitignore": true,
-  "config": {
-    // Consecutive header levels (h1 -> h2 -> h3).
-    "MD001": false,
-    // Header style. We use #s.
-    "MD003": {
-      "style": "atx"
-    },
-    // Style of unordered lists..
-    "MD007": {
-      "indent": 2,
-      "start_indented": true
-    },
-    // Line length. Who cares.
-    "MD013": false,
-    // This warns if you have "console" or "shell" code blocks with a dollar sign $ that
-    // don't show output. We use those a lot, so this is fine for us.
-    "MD014": false,
-    // Multiple headings with the same content.
-    "MD024": {
-      // Duplication is allowed for headings with different parents.
-      "siblings_only": true
-    },
-    // Trailing punctuation in heading.
-    // Some headers finish with ! because it refers to a function name. Therefore we remove ! from
-    // the default values.
-    "MD026": {
-      "punctuation": ".,;:。，；：！"
-    },
-    // Allow empty line between block quotes. Used by contiguous admonition blocks.
-    "MD028": false,
-    // Allowed HTML inline elements.
-    "MD033": {
-      "allowed_elements": [
-        "h1",
-        "a",
-        "br",
-        "img",
-        "picture",
-        "source",
-        "noscript",
-        "p",
-        "script"
-      ]
-    },
-    // This warns if you have spaces in code blocks. Sometimes, that's fine.
-    "MD038": false,
-    // Code block style. We don't care if it's fenced or indented.
-    "MD046": false,
-    // Our tables are too large to align.
-    "MD060": false
-  }
-}

.ort.yml

@@ -1,123 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-excludes:
-  paths:
-    - pattern: "man/*"
-      reason: "DOCUMENTATION_OF"
-      comment: "Documentation"
-    - pattern: ".github/**/*"
-      reason: "BUILD_TOOL_OF"
-      comment: "Documentation"
-    - pattern: ".ort/**/*"
-      reason: "BUILD_TOOL_OF"
-      comment: "Documentation"
-
-    # Unfortunately we'll have to repeat all package level excludes here
-    # Make sure to keep them in sync with the package configuration in
-    # .ort/package-configurations
-    - pattern: "lib/*/pages/**/*"
-      reason: "DOCUMENTATION_OF"
-      comment: "Documentation"
-    - pattern: "lib/*/test/**/*"
-      reason: "TEST_OF"
-      comment: "Tests"
-    - pattern: "lib/*/scripts/**/*"
-      reason: "BUILD_TOOL_OF"
-      comment: "Build Tool"
-    - pattern: "lib/*/examples/**/*"
-      reason: "EXAMPLE_OF"
-      comment: "Example"
-
-curations:
-  license_findings:
-    # Version File
-    - path: "VERSION"
-      reason: "NOT_DETECTED"
-      comment: "Apply Trademark Policy to VERSION file"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-    - path: ".github/pull_request_template.md"
-      reason: "NOT_DETECTED"
-      comment: "Apply default license to GitHub pull request template"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-
-    # Wrongly Identified
-    - path: ".gitignore"
-      reason: "INCORRECT"
-      comment: "Ignored by ScanCode"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-    - path: ".gitattributes"
-      reason: "INCORRECT"
-      comment: "Ignored by ScanCode"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-    - path: "CONTRIBUTING.md"
-      reason: "INCORRECT"
-      comment: "Wrongly identified TSL license"
-      detected_license: "Apache-2.0 OR NOASSERTION OR LicenseRef-scancode-tsl-2020"
-      concluded_license: "Apache-2.0"
-    - path: "OPEN_SOURCE_POLICY.md"
-      reason: "INCORRECT"
-      comment: "Wrongly identified NOASSERTION"
-      detected_license: "NOASSERTION"
-      concluded_license: "Apache-2.0"
-
-    # Unfortunately we'll have to repeat all package level license curations here
-    # Make sure to keep them in sync with the package configuration in
-    # .ort/package-configurations
-
-    # Test Fixtures
-    - path: "lib/*/test/fixtures/**/*"
-      reason: "NOT_DETECTED"
-      comment: "Apply default license to test fixtures"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-
-    # Logos
-    - path: "lib/elixir/pages/images/logo.png"
-      reason: "NOT_DETECTED"
-      comment: "Apply Trademark Policy to Elixir Logo"
-      detected_license: "NONE"
-      concluded_license: "LicenseRef-elixir-trademark-policy"
-    - path: "lib/elixir/scripts/windows_installer/assets/Elixir.ico"
-      reason: "NOT_DETECTED"
-      comment: "Apply Trademark Policy to Elixir Logo"
-      detected_license: "NONE"
-      concluded_license: "LicenseRef-elixir-trademark-policy"
-
-    # Documentation Images
-    - path: "lib/elixir/pages/images/**/*.png"
-      reason: "NOT_DETECTED"
-      comment: "Apply default license to all images"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-
-    # Test Fixtures
-    - path: "lib/elixir/test/elixir/fixtures/**/*"
-      reason: "NOT_DETECTED"
-      comment: "Apply default license to test fixtures"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"
-
-    # Unicode
-    - path: "lib/elixir/unicode/*.txt"
-      reason: "NOT_DETECTED"
-      comment: "Apply default license to unicode files"
-      detected_license: "NONE"
-      concluded_license: "LicenseRef-scancode-unicode"
-
-    # Wrongly Identified
-    - path: "lib/elixir/pages/references/library-guidelines.md"
-      reason: "INCORRECT"
-      comment: |
-        The guide mentions multiple licenses for users to choose from.
-        It however is not licensed itself by the mentioned licenses.
-      concluded_license: "Apache-2.0"
-    - path: "lib/elixir/scripts/windows_installer/.gitignore"
-      reason: "INCORRECT"
-      comment: "Ignored by ScanCode"
-      detected_license: "NONE"
-      concluded_license: "Apache-2.0"

.ort/config/config.yml

@@ -1,21 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-ort:
-  enableRepositoryPackageCurations: true
-  enableRepositoryPackageConfigurations: true
-
-  scanner:
-    skipConcluded: false
-    includeFilesWithoutFindings: true
-
-  analyzer:
-    allowDynamicVersions: true
-    enabledPackageManagers: [SpdxDocumentFile]
-
-  reporter:
-    reporters:
-      SpdxDocument:
-        options:
-          creationInfoOrganization: The Elixir Team
-          documentName: "Elixir Source SPDX Document"

.ort/config/evaluator.rules.kts

@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2019 The ORT Project Authors (see <https://github.com/oss-review-toolkit/ort/blob/main/NOTICE>)
- * Copyright (c) 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
- *
- * 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.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
- // Docs: https://oss-review-toolkit.org/ort/docs/configuration/evaluator-rules
-
-val whitelistedLicenses = listOf(
-  // License for Elixir & Imported Erlang Projects
-  "Apache-2.0",
-  // License for the Elixir Logo
-  "LicenseRef-elixir-trademark-policy",
-  "LicenseRef-scancode-elixir-trademark-policy",
-  // License for included Unicode Files
-  "LicenseRef-scancode-unicode",
-  // DCO for committers
-  "LicenseRef-scancode-dco-1.1"
-).map { SpdxSingleLicenseExpression.parse(it) }.toSet()
-
-fun PackageRule.howToFixDefault() = """
-      * Check if this license violation is intended
-      * Adjust evaluation rules in `.ort/config/evaluator.rules.kts`
-    """.trimIndent()
-
-fun PackageRule.LicenseRule.isHandled() =
-  object : RuleMatcher {
-    override val description = "isHandled($license)"
-
-    override fun matches() = license in whitelistedLicenses
-  }
-
-fun RuleSet.unhandledLicenseRule() = packageRule("UNHANDLED_LICENSE") {
-  // Do not trigger this rule on packages that have been excluded in the .ort.yml.
-  require {
-    -isExcluded()
-  }
-
-  // Define a rule that is executed for each license of the package.
-  licenseRule("UNHANDLED_LICENSE", LicenseView.CONCLUDED_OR_DECLARED_AND_DETECTED) {
-    require {
-      -isExcluded()
-      -isHandled()
-    }
-
-    // Throw an error message including guidance how to fix the issue.
-    error(
-      "The license $license is currently not covered by policy rules. " +
-        "The license was ${licenseSource.name.lowercase()} in package " +
-        "${pkg.metadata.id.toCoordinates()}.",
-      howToFixDefault()
-    )
-  }
-}
-
-fun RuleSet.unmappedDeclaredLicenseRule() = packageRule("UNMAPPED_DECLARED_LICENSE") {
-  require {
-    -isExcluded()
-  }
-
-  resolvedLicenseInfo.licenseInfo.declaredLicenseInfo.processed.unmapped.forEach { unmappedLicense ->
-    warning(
-      "The declared license '$unmappedLicense' could not be mapped to a valid license or parsed as an SPDX " +
-        "expression. The license was found in package ${pkg.metadata.id.toCoordinates()}.",
-      howToFixDefault()
-    )
-  }
-}
-
-val ruleSet = ruleSet(ortResult, licenseInfoResolver, resolutionProvider) {
-  unhandledLicenseRule()
-  unmappedDeclaredLicenseRule()
-}
-
-ruleViolations += ruleSet.violations

.ort/package-configurations/eex.yml

@@ -1,15 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-id: "SpdxDocumentFile:The Elixir Team:eex:"
-path_excludes:
-  - pattern: "lib/eex/test/**/*"
-    reason: "TEST_OF"
-    comment: "Tests"
-license_finding_curations:
-  # Test Fixtures
-  - path: "lib/eex/test/fixtures/**/*"
-    reason: "NOT_DETECTED"
-    comment: "Apply default license to test fixtures"
-    detected_license: "NONE"
-    concluded_license: "Apache-2.0"

.ort/package-configurations/elixir.yml

@@ -1,60 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-id: "SpdxDocumentFile:The Elixir Team:elixir:"
-path_excludes:
-  - pattern: "lib/elixir/pages/**/*"
-    reason: "DOCUMENTATION_OF"
-    comment: "Documentation"
-  - pattern: "lib/elixir/scripts/**/*"
-    reason: "BUILD_TOOL_OF"
-    comment: "Build Tool"
-  - pattern: "lib/elixir/test/**/*"
-    reason: "TEST_OF"
-    comment: "Tests"
-license_finding_curations:
-  # Logos
-  - path: "lib/elixir/pages/images/logo.png"
-    reason: "NOT_DETECTED"
-    comment: "Apply Trademark Policy to Elixir Logo"
-    detected_license: "NONE"
-    concluded_license: "LicenseRef-elixir-trademark-policy"
-  - path: "lib/elixir/scripts/windows_installer/assets/Elixir.ico"
-    reason: "NOT_DETECTED"
-    comment: "Apply Trademark Policy to Elixir Logo"
-    detected_license: "NONE"
-    concluded_license: "LicenseRef-elixir-trademark-policy"
-
-  # Documentation Images
-  - path: "lib/elixir/pages/images/**/*.png"
-    reason: "NOT_DETECTED"
-    comment: "Apply default license to all images"
-    detected_license: "NONE"
-    concluded_license: "Apache-2.0"
-
-  # Test Fixtures
-  - path: "lib/elixir/test/elixir/fixtures/**/*"
-    reason: "NOT_DETECTED"
-    comment: "Apply default license to test fixtures"
-    detected_license: "NONE"
-    concluded_license: "Apache-2.0"
-
-  # Unicode
-  - path: "lib/elixir/unicode/*.txt"
-    reason: "NOT_DETECTED"
-    comment: "Apply default license to unicode files"
-    detected_license: "NONE"
-    concluded_license: "LicenseRef-scancode-unicode"
-
-  # Wrongly Identified
-  - path: "lib/elixir/pages/references/library-guidelines.md"
-    reason: "INCORRECT"
-    comment: |
-      The guide mentions multiple licenses for users to choose from.
-      It however is not licensed itself by the mentioned licenses.
-    concluded_license: "Apache-2.0"
-  - path: "lib/elixir/scripts/windows_installer/.gitignore"
-    reason: "INCORRECT"
-    comment: "Ignored by ScanCode"
-    detected_license: "NONE"
-    concluded_license: "Apache-2.0"

.ort/package-configurations/ex_unit.yml

@@ -1,18 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-id: "SpdxDocumentFile:The Elixir Team:exunit:"
-path_excludes:
-  - pattern: "lib/ex_unit/examples/**/*"
-    reason: "EXAMPLE_OF"
-    comment: "Example"
-  - pattern: "lib/ex_unit/test/**/*"
-    reason: "TEST_OF"
-    comment: "Tests"
-license_finding_curations:
-  # Test Fixtures
-  - path: "lib/ex_unit/test/fixtures/**/*"
-    reason: "NOT_DETECTED"
-    comment: "Apply default license to test fixtures"
-    detected_license: "NONE"
-    concluded_license: "Apache-2.0"

.ort/package-configurations/logger.yml

@@ -1,8 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-id: "SpdxDocumentFile:The Elixir Team:logger:"
-path_excludes:
-  - pattern: "lib/logger/test/**/*"
-    reason: "TEST_OF"
-    comment: "Tests"

.ort/package-configurations/mix.yml

@@ -1,15 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-id: "SpdxDocumentFile:The Elixir Team:mix:"
-path_excludes:
-  - pattern: "lib/mix/test/**/*"
-    reason: "TEST_OF"
-    comment: "Tests"
-license_finding_curations:
-  # Test Fixtures
-  - path: "lib/mix/test/fixtures/**/*"
-    reason: "NOT_DETECTED"
-    comment: "Apply default license to test fixtures"
-    detected_license: "NONE"
-    concluded_license: "Apache-2.0"

.travis.yml

@@ -0,0 +1,10 @@
+language: erlang
+script: "make compile && rm -rf .git && make test"
+notifications:
+  irc: "irc.freenode.org#elixir-lang"
+  recipients:
+    - jose.valim@plataformatec.com.br
+    - eric.meadows.jonsson@gmail.com
+otp_release:
+  - 17.0
+  - 17.1

AGENTS.md

@@ -1 +0,0 @@
-CONTRIBUTING.md

CODE_OF_CONDUCT.md

@@ -1,72 +0,0 @@
-<!--
-  SPDX-License-Identifier: Apache-2.0
-  SPDX-FileCopyrightText: 2021 The Elixir Team
-  SPDX-FileCopyrightText: 2012 Plataformatec
--->
-
-# Code of Conduct
-
-Contact: <elixir-lang-conduct@googlegroups.com>
-
-## Why have a Code of Conduct?
-
-As contributors and maintainers of this project, we are committed to providing a friendly, safe and welcoming environment for all, regardless of age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
-
-The goal of the Code of Conduct is to specify a baseline standard of behavior so that people with different social values and communication styles can talk about Elixir effectively, productively, and respectfully, even in face of disagreements. The Code of Conduct also provides a mechanism for resolving conflicts in the community when they arise.
-
-## Our Values
-
-These are the values Elixir developers should aspire to:
-
-  * Be friendly and welcoming
-  * Be kind
-    * 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.
-
-The following actions are explicitly forbidden:
-
-  * Insulting, demeaning, hateful, or threatening remarks.
-  * Discrimination based on age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
-  * Bullying or systematic harassment.
-  * Unwelcome sexual advances.
-  * Incitement to any of these.
-
-## Where does the Code of Conduct apply?
-
-If you participate in or contribute to the Elixir ecosystem in any way, you are encouraged to follow the Code of Conduct while doing so.
-
-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 elixir-lang mailing lists.
-  * The **[#elixir][2]** IRC channel on [Libera.Chat][3].
-
-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.
-
-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.
-
-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**.
-
-**The goal of the Code of Conduct is to resolve conflicts in the most harmonious way possible**. We hope that in most cases issues may be resolved through polite discussion and mutual agreement. Bannings and other forceful measures are to be employed only as a last resort. **Do not** post about the issue publicly or try to rally sentiment against a particular individual or group.
-
-## 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/

CONTRIBUTING.md

@@ -1,244 +1,265 @@
-<!--
-  SPDX-License-Identifier: Apache-2.0
-  SPDX-FileCopyrightText: 2021 The Elixir Team
-  SPDX-FileCopyrightText: 2012 Plataformatec
--->
-
 # Contributing to Elixir
 
-We invite contributions to Elixir. To contribute, there are a few
-things you need to know about the code. First, Elixir code is divided
-by each application inside the `lib` folder:
+Please take a moment to review this document in order to make the contribution
+process easy and effective for everyone involved!
 
-  * `elixir` - Elixir's kernel and standard library
+## Using the issue tracker
 
-  * `eex` - EEx is the template engine that allows you to embed Elixir
+Use the issues tracker for:
 
-  * `ex_unit` - ExUnit is a simple test framework that ships with Elixir
+* [bug reports](#bugs-reports)
+* [submitting pull requests](#pull-requests)
 
-  * `iex` - IEx stands for Interactive Elixir: Elixir's interactive shell
+Please **do not** use the issue tracker for personal support requests nor feature requests. Support requests should be sent to:
 
-  * `logger` - Logger is the built-in logger
+* [the elixir-talk mailing list](http://groups.google.com/group/elixir-lang-talk)
+* [Stack Overflow](http://stackoverflow.com/questions/ask?tags=elixir)
+* [#elixir-lang](irc://chat.freenode.net/elixir-lang)
 
-  * `mix` - Mix is Elixir's build tool
+Feature requests can be discussed on [the elixir-core mailing list](http://groups.google.com/group/elixir-lang-core).
 
-You can run all tests in the root directory with `make test`. You can
-also run tests for a specific framework with `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`.
+We do our best to keep the issue tracker tidy and organized, making it useful
+for everyone. For example, we classify open issues per application and perceived
+difficulty of the issue, making it easier for developers to
+[contribute to Elixir](#contributing).
 
-If you are only changing one file, you can choose to compile and run tests
-for that specific file for faster development cycles. For example, if you
+## Bug reports
+
+A bug is a _demonstrable problem_ that is caused by the code in the repository.
+Good bug reports are extremely helpful - thank you!
+
+Guidelines for bug reports:
+
+1. **Use the GitHub issue search** &mdash; check if the issue has already been
+   reported.
+
+2. **Check if the issue has been fixed** &mdash; try to reproduce it using the
+   `master` branch in the repository.
+
+3. **Isolate and report the problem** &mdash; ideally create a reduced test
+   case.
+
+Please try to be as detailed as possible in your report. Include information about
+your Operating System, your Erlang and Elixir versions. Please provide steps to
+reproduce the issue as well as the outcome you were expecting! All these details
+will help developers to fix any potential bugs.
+
+Example:
+
+> Short and descriptive example bug report title
+>
+> A summary of the issue and the environment in which it occurs. If suitable,
+> include the steps required to reproduce the bug.
+>
+> 1. This is the first step
+> 2. This is the second step
+> 3. Further steps, etc.
+>
+> `<url>` - a link to the reduced test case (e.g. a GitHub Gist)
+>
+> Any other information you want to share that is relevant to the issue being
+> reported. This might include the lines of code that you have identified as
+> causing the bug, and potential solutions (and your opinions on their
+> merits).
+
+## Feature requests
+
+Feature requests are welcome and should be discussed on [the elixir-core mailing list](http://groups.google.com/group/elixir-lang-core). But take a moment to find
+out whether your idea fits with the scope and aims of the project. It's up to *you*
+to make a strong case to convince the community of the merits of this feature.
+Please provide as much detail and context as possible.
+
+## Contributing
+
+We incentivize 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` - Contains Elixir's kernel and stdlib
+
+* `eex` - Template engine that allows you to embed Elixir
+
+* `ex_unit` - Simple test framework that ships with Elixir
+
+* `iex` — IEx, Elixir's interactive shell
+
+* `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_#{NAME}`, for example,
+`make test_ex_unit`.
+
+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:
 
-```sh
-bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
-bin/elixir lib/elixir/test/elixir/string_test.exs
-```
+    $ bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
+    $ bin/elixir lib/elixir/test/elixir/string_test.exs
 
-Some test files need their `test_helper.exs` to be explicitly required
-before, such as:
-
-```sh
-bin/elixir -r lib/logger/test/test_helper.exs lib/logger/test/logger_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 all (including Erlang modules):
-
-```sh
-make compile
-```
-
-After your changes are done, run `make format` to guarantee
-all files are properly formatted, then run the full suite with
+After your changes are done, please remember to run the full suite with
 `make test`.
 
-If your contribution fails during the bootstrapping of the language,
-you can rebuild the language from scratch with:
+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).
 
-```sh
-make clean_elixir compile
+With tests running and passing, you are ready to contribute to Elixir and
+send your pull requests.
+
+## Contributing Documentation
+
+Code documentation (`@doc`, `@moduledoc`, `@typedoc`) has a special convention:
+the first paragraph is considered to be a short summary.
+
+For functions, macros and callbacks say what it will do. For example write
+something like:
+
+```elixir
+@doc """
+Returns only those elements for which `fun` is true.
+
+...
+"""
+def filter(collection, fun) ...
 ```
 
-Similarly, if you can not 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).
+For modules, protocols and types say what it is. For example write
+something like:
 
-## Sending a pull request
+```elixir
+defmodule File.Stat do
+  @moduledoc """
+  Information about a file.
 
-Contributions are done [via pull request](https://help.github.com/articles/using-pull-requests/)
-and must include tests and other relevant proof of work:
+  ...
+  """
 
-  * **Bug Fixes:** If you are fixing a bug, include a test that *fails* before
-    your change and *passes* afterward. This makes it easier to confirm that the
-    fix addresses the underlying issue and helps prevent regressions in the future.
-
-  * **New Features or Major Changes:** If you are adding a new feature or making
-    major changes to existing functionality, please add assocaited tests. Aim to
-    have the best code coverage possible.
-
-  * **Performance improvements:** For performance improvements, please include the
-    benchmark script, with inputs and results, in the pull request description.
-    We recommend using [benchee](https://github.com/bencheeorg/benchee).
-
-Here are some pull requests we have received in the past you can use as reference:
-
-  * [Implement Enum.member?](https://github.com/elixir-lang/elixir/pull/992)
-
-  * [Add String.valid?](https://github.com/elixir-lang/elixir/pull/1058)
-
-  * [Implement capture_io for ExUnit](https://github.com/elixir-lang/elixir/pull/1059)
-
-## Reviewing changes
-
-Once a pull request is sent, the Elixir team will review your changes.
-If 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.
-
-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.
-
-## Building documentation
-
-Building the documentation requires that [ExDoc](https://github.com/elixir-lang/ex_doc)
-is cloned and compiled alongside Elixir.
-
-After cloning and compiling Elixir, run:
-
-```sh
-elixir_dir=$(pwd)
-cd .. && git clone https://github.com/elixir-lang/ex_doc.git
-cd ex_doc && "${elixir_dir}/bin/elixir" "${elixir_dir}/bin/mix" do deps.get + compile
-
-# Now we will go back to Elixir's root directory,
-cd "${elixir_dir}"
-
-# and generate HTML and EPUB documents:
-make docs
+  defstruct [...]
+end
 ```
 
-This will produce documentation sets for `elixir`, `eex`, `ex_unit`, `iex`, `logger`,
-and `mix` under the `doc` directory. If you are planning to contribute documentation,
-[please check our best practices for writing documentation](https://elixir.hexdocs.pm/writing-documentation.html).
+Keep in mind that the first paragraph might show up in a summary somewhere, long
+texts in the first paragraph create very ugly summaries. As a rule of thumb
+anything longer than 80 characters is too long.
 
-## Licensing and Compliance Requirements
+Try to keep unneccesary details out of the first paragraph, it's only there to
+give a user a quick idea of what the documented "thing" does/is. The rest of the
+documentation string can contain the details, for example when a value and when
+`nil` is returned.
 
-Please review our [Open Source Policy](OPEN_SOURCE_POLICY.md) for complete
-guidelines on licensing and compliance. Below is a summary of the key points
-affecting **all external contributors**:
+If possible include examples, preferably in a form that works with doctests. For
+example:
 
-  * Accepted Licenses: Any code contributed must be licensed under the
-    `Apache-2.0` license.
+```elixir
+@doc """
+Return only those elements for which `fun` is true.
 
-  * SPDX License Headers: With the exception of approved test fixture files,
-    all new or modified files in a pull request must include correct SPDX
-    headers. If you are creating a new file under the `Apache-2.0` license, for
-    instance, please use:
+## Examples
 
-    ```elixir
-    # SPDX-License-Identifier: Apache-2.0
-    # SPDX-FileCopyrightText: 2021 The Elixir Team
-    ```
+    iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+    [2]
 
-  * No Executable Binaries: Contributions must **not** include any executable
-    binary files. If you require an exception (for example, certain test artifacts),
-    please see the policy on how to request approval and document exceptions.
+"""
+def filter(collection, fun) ...
+```
 
-  * Preserving Copyright and License Info: If you copy code from elsewhere,
-    ensure that **all original copyright and license notices remain intact**. If
-    they are missing or incomplete, you must add them.
+This makes it easy to test the examples so that they don't go stale and examples
+are often a great help in explaining what a function does.
 
-  * Failure to Comply: Pull requests that do not meet these licensing and
-    compliance standards will be rejected or require modifications before merging.
+## Pull requests
 
-  * Developer Certificate of Origin: All contributions are subject to the
-    Developer Certificate of Origin.
+Good pull requests - patches, improvements, new features - are a fantastic
+help. They should remain focused in scope and avoid containing unrelated
+commits.
 
-    ```text
-    By making a contribution to this project, I certify that:
+**IMPORTANT**: By submitting a patch, you agree that your work will be
+licensed under the license used by the project.
 
-    (a) The contribution was created in whole or in part by me and I
-        have the right to submit it under the open source license
-        indicated in the file; or
+If you have any large pull request in mind (e.g. implementing features,
+refactoring code, etc), **please ask first** otherwise you risk spending
+a lot of time working on something that the project's developers might
+not want to merge into the project.
 
-    (b) The contribution is based upon previous work that, to the 
-        best of my knowledge, is covered under an appropriate open 
-        source license and I have the right under that license to   
-        submit that work with modifications, whether created in whole
-        or in part by me, under the same open source license (unless
-        I am permitted to submit under a different license), as 
-        Indicated in the file; or
+Please adhere to the coding conventions in the project (indentation,
+accurate comments, etc.) and don't forget to add your own tests and
+documentation. When working with git, we recommend the following process
+in order to craft an excellent pull request:
 
-    (c) The contribution was provided directly to me by some other
-        person who certified (a), (b) or (c) and I have not modified
-        it.
+1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork,
+   and configure the remotes:
 
-    (d) I understand and agree that this project and the contribution
-        are public and that a record of the contribution (including 
-        all personal information I submit with it, including my
-        sign-off) is maintained indefinitely and may be redistributed
-        consistent with this project or the open source license(s)
-        involved.
-    ```
+   ```bash
+   # Clone your fork of the repo into the current directory
+   git clone https://github.com/<your-username>/elixir
+   # Navigate to the newly cloned directory
+   cd elixir
+   # Assign the original repo to a remote called "upstream"
+   git remote add upstream https://github.com/elixir-lang/elixir
+   ```
 
-    See <https://developercertificate.org/> for a copy of the Developer Certificate
-    of Origin license.
+2. If you cloned a while ago, get the latest changes from upstream:
 
-## Using AI and coding agents
+   ```bash
+   git checkout master
+   git pull upstream master
+   ```
 
-While we allow the use of AI on contributions and discussions, please be mindful
-when doing so. Generally speaking, Elixir maintainers already have access to AI
-(like many other developers). Therefore, if we need the feedback or help of a
-coding agent, we can request so ourselves. For this reason, we often find
-the point of view of the human behind the agent more valuable.
+3. Create a new topic branch (off of `master`) to contain your feature, change,
+   or fix.
 
-That said, here are examples of how one might (or might not) use AI and coding
-agents in Elixir spaces:
+   **IMPORTANT**: Making changes in `master` is discouraged. You should always
+   keep your local `master` in sync with upstream `master` and make your
+   changes in topic branches.
 
-  * When it comes to discussions, using AI to help express yourself is welcome,
-    but avoid directly copy and pasting AI generated content. If there is a language
-    barrier, use AI to translate, review, and improve your text, but do not use AI
-    to respond on your behalf.
+   ```bash
+   git checkout -b <topic-branch-name>
+   ```
 
-  * Do not use coding agents to tackle existing issues unless they have the
-    "Contributions Welcome" label.
+4. Commit your changes in logical chunks. Keep your commit messages organized,
+   with a short description in the first line and more detailed information on
+   the following lines. Feel free to use Git's
+   [interactive rebase](https://help.github.com/articles/interactive-rebase)
+   feature to tidy up your commits before making them public.
 
-  * If you request a feature on the mailing list and it is accepted, you may
-    use coding agents to implement it, as long as it follows the AI Contributions
-    guidelines below.
+5. Make sure all the tests are still passing.
 
-  * When automating AI usage on the Elixir codebase for performance improvements,
-    security fixes, or correctness changes to the compiler or type system, pair it
-    with a separate set of agents whose job is to argue against and try to invalidate
-    any proposed change. And treat their approval as advisory: a human must still
-    validate it before opening issues or pull requests.
+   ```bash
+   make test
+   ```
 
-If any code is written by AI, then you must follow the guidelines below.
+   This command will compile the code in your branch and use that
+   version of Elixir to run the tests. This is needed to ensure your changes can
+   pass all the tests.
 
-### AI contributions
+6. Push your topic branch up to your fork:
 
-AI agents MUST NOT add Signed-off-by tags. Only humans can legally certify the Developer
-Certificate of Origin (DCO). The human submitter is responsible for:
+   ```bash
+   git push origin <topic-branch-name>
+   ```
 
-  * Reviewing all AI-generated code
-  * Ensuring compliance with licensing requirements
-  * Adding their own Signed-off-by tag to certify the DCO
-  * Taking full responsibility for the contribution
-  * Disclosing use of AI for comments and code contributions
+7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
+    with a clear title and description.
 
-When AI tools contribute to Elixir, proper attribution helps track the evolving role of
-AI in the development process. Contributions should include an Assisted-by tag in the
-following format:
+8. If you haven't updated your pull request for a while, you should consider
+   rebasing on master and resolving any conflicts.
 
-    Assisted-by: AGENT_NAME:MODEL_VERSION
+   **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You
+   should always `git rebase` on `master` to bring your changes up to date when
+   necessary.
+
+   ```bash
+   git checkout master
+   git pull upstream master
+   git checkout <your-topic-branch>
+   git rebase master
+   ```
+
+We have saved some excellent pull requests we have received in the past in case
+you are looking for some examples:
+
+* https://github.com/elixir-lang/elixir/pull/992
+* https://github.com/elixir-lang/elixir/pull/1058
+* https://github.com/elixir-lang/elixir/pull/1059
+
+Thank you for your contributions!

LEGAL

@@ -0,0 +1,8 @@
+LEGAL NOTICE INFORMATION
+------------------------
+
+All the files in this distribution are covered under either Elixir's
+license (see the file LICENSE) except the files mentioned below that
+contains sections that are under Erlang's License (EPL):
+
+lib/elixir/src/elixir_parser.erl (generated by build scripts)

LICENSE

@@ -1,176 +1,13 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+Copyright 2012-2013 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.

LICENSES/Apache-2.0.txt

@@ -1,73 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-"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
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-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
-
-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,
-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.

LICENSES/LicenseRef-elixir-trademark-policy.txt

@@ -1,98 +0,0 @@
-ELIXIR TEAM TRADEMARKS POLICY
-
-This document outlines the policy for allowed usage of the “Elixir” word and the
-Elixir logo by other parties.
-
-“Elixir” and the Elixir logo are registered trademarks of the Elixir Team. The
-Elixir Team believes in a decentralized approach to growing the community and
-the ecosystem, independent of the Elixir project and the Elixir Team.
-
-Anyone can use the Elixir trademarks if that use of the trademark is nominative.
-The trademarks must not be used to disparage the project and its community, nor
-be used in any way to imply ownership, endorsement, or association with the
-Elixir project and the Elixir Team.
-
-You must not visually combine the Elixir logo with any other images, or change
-the logo in any way other than ways required by printing restrictions. If you
-want to create your own visual identity in relation to Elixir, you might use the
-shape of an unrelated “water drop” as part of your design, as seen in many
-community projects and initiatives. You must not combine or modify the Elixir
-logo.
-
-The Elixir logo is available in our repository in both vertical and horizontal
-versions.
-
-Nominative use
-The “nominative use” (or “nominative fair use”) is a legal doctrine that
-authorizes everyone (even commercial companies) to use or refer to the trademark
-of another if:
-
-The product or service in question must be one not readily identifiable without
-use of the trademark.
-
-Only so much of the mark or marks may be used as is reasonably necessary to
-identify the product or service.
-
-The organization using the mark must do nothing that would, in conjunction with
-the mark, suggest sponsorship or endorsement by the trademark holder.
-
-Our trademarks must be used to refer to the Elixir programming language.
-
-Examples of permitted use
-All examples listed next must strictly adhere to the terms outlined in the
-previous sections:
-
-Usage of the Elixir logo to say a technology is “powered by Elixir” under
-nominative use. Linking back to the Elixir website, if possible, is appreciated.
-
-Usage of the Elixir logo to display it as a supported technology in a service or
-platform. For instance, you may say “we support Elixir” and use the Elixir logo,
-but you may not refer to yourself as “the Elixir platform” nor imply any form of
-endorsement or association with Elixir.
-
-Usage of the Elixir logo in non-commercial community meetups, in presentations,
-and in courses when referring to the language and its ecosystem under nominative
-use.
-
-Usage of the Elixir logo in non-commercial swag (stickers, t-shirts, mugs, etc)
-to promote the Elixir programming language. The Elixir marks must be the only
-marks featured in the product. You need permission to make swag that include
-Elixir and other third party marks in them.
-
-Inclusion of the Elixir logo in non-commercial icon sets. Use of the Elixir
-icons must still adhere to Elixir’s trademark policies.
-
-Usage of the “Elixir” word in book titles, meetups, conferences, and podcasts.
-You must not use the word to imply uniqueness or endorsement from the Elixir
-team. “The Elixir book” and “The Elixir podcast” are not permitted.
-“Elixir in Action”, “Thinking Elixir”, and “Kraków Elixir User Group” are valid
-examples already in use today.
-
-Usage of the “Elixir” word in the names of freely distributed software and
-hardware products is allowed when referring to use with or suitability for the
-Elixir programming language, such as wxElixir, Elixirsense, etc. If the product
-includes the Elixir programming language itself, then you must also respect its
-license.
-
-Examples of not permitted use
-Here is a non-exhaustive list of non permitted uses of the marks:
-
-Usage of the Elixir logo in book covers, conferences, and podcasts.
-
-Usage of the Elixir logo as the mark of third party projects, even in combination
-with other marks.
-
-Naming any company or product after Elixir, such as “The Elixir Hosting”,
-“The Elixir Consultants”, etc.
-
-Examples that require permission
-Here are some examples that may be granted permission upon request:
-
-Selling merchandise (stickers, t-shirts, mugs, etc).
-You can request permission by emailing trademarks@elixir-lang.org.
-
-Important note
-Nothing in this page shall be interpreted to allow any third party to claim any
-association with the Elixir project and the Elixir Team, or to imply any
-approval or support by the Elixir project and the Elixir Team for any third
-party products, services, or events.

LICENSES/LicenseRef-scancode-unicode.txt

@@ -1,58 +0,0 @@
-UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
-
-Unicode Data Files include all data files under the directories
-http://www.unicode.org/Public/, http://www.unicode.org/reports/, and
-http://www.unicode.org/cldr/data/ . Unicode Software includes any source
-code published in the Unicode Standard or under the directories
-http://www.unicode.org/Public/, http://www.unicode.org/reports/, and
-http://www.unicode.org/cldr/data/.
-
-NOTICE TO USER: Carefully read the following legal agreement. BY
-DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA
-FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU UNEQUIVOCALLY
-ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS
-AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE
-OR USE THE DATA FILES OR SOFTWARE.
-
-COPYRIGHT AND PERMISSION NOTICE
-
-Copyright ©  Unicode, Inc. All rights reserved. Distributed under
-the Terms of Use in http://www.unicode.org/copyright.html.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of the Unicode data files and any associated documentation (the
-"Data Files") or Unicode software and any associated documentation (the
-"Software") to deal in the Data Files or Software without restriction,
-including without limitation the rights to use, copy, modify, merge,
-publish, distribute, and/or sell copies of the Data Files or Software,
-and to permit persons to whom the Data Files or Software are furnished
-to do so, provided that
-
-(a) the above copyright notice(s) and this permission notice appear with
-all copies of the Data Files or Software,
-
-(b) both the above copyright notice(s) and this permission notice appear
-in associated documentation, and
-
-(c) there is clear notice in each modified Data File or in the Software
-as well as in the documentation associated with the Data File(s) or
-Software that the data or software has been modified.
-
-THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR
-ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
-RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
-CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
-CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder shall
-not be used in advertising or otherwise to promote the sale, use or
-other dealings in these Data Files or Software without prior written
-authorization of the copyright holder.
-
-Unicode and the Unicode logo are trademarks of Unicode, Inc., and may be
-registered in some jurisdictions. All other trademarks and registered
-trademarks mentioned herein are the property of their respective owners.

Makefile

@@ -1,124 +1,93 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-PREFIX ?= /usr/local
-TEST_FILES ?= "*_test.exs"
-SHARE_PREFIX ?= $(PREFIX)/share
-MAN_PREFIX ?= $(SHARE_PREFIX)/man
-CANONICAL := main/
-ELIXIRC := bin/elixirc --ignore-module-conflict $(ELIXIRC_OPTS)
-ELIXIRC_MIN_SIG := $(ELIXIRC) -e 'Code.put_compiler_option :infer_signatures, []'
+REBAR := rebar
+ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
 ERLC := erlc -I lib/elixir/include
-ERL_MAKE := erl -make
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
-GENERATE_APP := $(CURDIR)/lib/elixir/scripts/generate_app.escript
 VERSION := $(strip $(shell cat VERSION))
 Q := @
+PREFIX := /usr/local
 LIBDIR := lib
-BINDIR := bin
 INSTALL = install
 INSTALL_DIR = $(INSTALL) -m755 -d
 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 | grep -v latest | tail -1))
-SOURCE_DATE_EPOCH_PATH = lib/elixir/tmp/ebin_reproducible
-SOURCE_DATE_EPOCH_FILE = $(SOURCE_DATE_EPOCH_PATH)/SOURCE_DATE_EPOCH
 
-.PHONY: cover install install_man build_plt clean_plt dialyze test check_reproducible clean clean_elixir clean_man format docs Docs.zip Precompiled.zip zips
-.NOTPARALLEL:
+.PHONY: install compile erlang elixir build_plt clean_plt dialyze test clean docs release_docs release_zip check_erlang_release
+.NOTPARALLEL: compile
 
 #==> Functions
 
+# This check should work for older versions like R16B
+# as well as new verions like 17.1 and 18
 define CHECK_ERLANG_RELEASE
-	erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 27)])' -s erlang halt | grep -q '^true'; \
-		if [ $$? != 0 ]; then \
-		  echo "At least Erlang/OTP 27.0 is required to build Elixir"; \
-		  exit 1; \
-		fi
+	$(Q) erl -noshell -eval 'io:fwrite("~s", [erlang:system_info(otp_release)])' -s erlang halt | grep -q '^1[789]'; \
+		if [ $$? != 0 ]; then                                                                                        \
+		   echo "At least Erlang 17.0 is required to build Elixir";                                                  \
+		   exit 1;                                                                                                   \
+		fi;
 endef
 
 define APP_TEMPLATE
 $(1): lib/$(1)/ebin/Elixir.$(2).beam lib/$(1)/ebin/$(1).app
 
 lib/$(1)/ebin/$(1).app: lib/$(1)/mix.exs
-	$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run("compile.app", ~w[--compile-path ebin])'
+	$(Q) mkdir -p lib/$(1)/_build/shared/lib/$(1)
+	$(Q) cp -R lib/$(1)/ebin lib/$(1)/_build/shared/lib/$(1)/
+	$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run("compile.app")'
+	$(Q) cp lib/$(1)/_build/shared/lib/$(1)/ebin/$(1).app lib/$(1)/ebin/$(1).app
+	$(Q) rm -rf lib/$(1)/_build
 
 lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1)/lib/*/*.ex) $(wildcard lib/$(1)/lib/*/*/*.ex)
 	@ echo "==> $(1) (compile)"
 	@ rm -rf lib/$(1)/ebin
 	$(Q) cd lib/$(1) && ../../$$(ELIXIRC) "lib/**/*.ex" -o ebin
 
-test_$(1): test_formatted $(1)
-	@ echo "==> $(1) (ex_unit)"
-	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/$(TEST_FILES)";
-
-cover/ex_unit_$(1).coverdata:
-	$(Q) COVER="1" $(MAKE) test_$(1)
-cover/combined.coverdata: cover/ex_unit_$(1).coverdata
-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)))
+test_$(1): $(1)
+	@ 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
-EEX := lib/eex/ebin/Elixir.EEx.beam
-ELIXIR := lib/elixir/ebin/elixir.beam
-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 elixir
+compile: lib/elixir/src/elixir.app.src erlang elixir
 
-erlang: $(ELIXIR)
-$(ELIXIR): $(PARSER) lib/elixir/src/*
-	$(Q) if [ ! -f $(APP) ]; then $(call CHECK_ERLANG_RELEASE); fi
-	$(Q) cd lib/elixir && mkdir -p ebin && $(ERL_MAKE)
-	$(Q) $(GENERATE_APP) $(VERSION)
+lib/elixir/src/elixir.app.src: src/elixir.app.src
+	$(Q) $(call CHECK_ERLANG_RELEASE)
+	$(Q) rm -rf lib/elixir/src/elixir.app.src
+	$(Q) echo "%% This file is automatically generated from <project_root>/src/elixir.app.src" \
+	                             >lib/elixir/src/elixir.app.src
+	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
 
-$(PARSER): lib/elixir/src/elixir_parser.yrl
-	$(Q) erlc -o $@ +'{verbose,true}' +'{report,true}' $<
+erlang:
+	$(Q) cd lib/elixir && ../../$(REBAR) compile
 
-# Since Mix depends on EEx and EEx depends on Mix,
-# we first compile EEx without the .app file,
-# then Mix, and then compile EEx fully
-elixir: stdlib $(EEX) mix ex_unit logger eex iex
-stdlib: $(KERNEL) $(UNICODE) $(APP)
+# Since Mix depends on EEx and EEx depends on
+# Mix, we first compile EEx without the .app
+# file, then mix and then compile EEx fully
+elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit logger eex iex
 
-$(KERNEL): lib/elixir/src/* lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex VERSION
-	$(Q) if [ ! -f $(KERNEL) ]; then \
-		echo "==> bootstrap (compile)"; \
-		$(ERL) -s elixir_compiler bootstrap -s erlang halt; \
-		"$(MAKE)" unicode; \
+stdlib: $(KERNEL) VERSION
+$(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
+	$(Q) if [ ! -f $(KERNEL) ]; then                    \
+		echo "==> bootstrap (compile)";                 \
+		$(ERL) -s elixir_compiler core -s erlang halt;  \
 	fi
 	@ echo "==> elixir (compile)";
-	$(Q) cd lib/elixir && ../../$(ELIXIRC_MIN_SIG) "lib/**/*.ex" -o ebin;
-	$(Q) $(GENERATE_APP) $(VERSION)
-	$(Q) bin/elixir lib/elixir/scripts/infer.exs;
-
-$(APP): lib/elixir/src/elixir.app.src $(GENERATE_APP)
-	$(Q) $(GENERATE_APP) $(VERSION)
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/kernel.ex" -o ebin;
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/**/*.ex" -o ebin;
+	$(Q) $(MAKE) unicode
+	$(Q) rm -rf lib/elixir/ebin/elixir.app
+	$(Q) cd lib/elixir && ../../$(REBAR) compile
 
 unicode: $(UNICODE)
 $(UNICODE): lib/elixir/unicode/*
 	@ echo "==> unicode (compile)";
-	$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/unicode.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/tokenizer.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/security.ex -o lib/elixir/ebin;
+	@ echo "Embedding the Unicode database... (this may take a while)"
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) unicode/unicode.ex -o ebin;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
 $(eval $(call APP_TEMPLATE,logger,Logger))
@@ -129,151 +98,65 @@ $(eval $(call APP_TEMPLATE,iex,IEx))
 install: compile
 	@ echo "==> elixir (install)"
 	$(Q) for dir in lib/*; do \
-		rm -rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
 		$(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 		$(INSTALL_DATA) $$dir/ebin/* "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 	done
 	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
 	$(Q) $(INSTALL_PROGRAM) $(filter-out %.ps1, $(filter-out %.bat, $(wildcard bin/*))) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
-	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(BINDIR)"
-	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/*; do \
-		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/$(BINDIR)/"; \
+	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/bin"
+	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/* ; do \
+		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/bin/" ; \
 	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/
-	$(Q) rm -rf lib/*/ebin
-	SOURCE_DATE_EPOCH=$(call READ_SOURCE_DATE_EPOCH) "$(MAKE)" compile
-	$(Q) echo "Diffing..."
-	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/elixir/ebin/ lib/elixir/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/eex/ebin/ lib/eex/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/ex_unit/ebin/ lib/ex_unit/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/iex/ebin/ lib/iex/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/logger/ebin/ lib/logger/tmp/ebin_reproducible/
-	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/mix/ebin/ lib/mix/tmp/ebin_reproducible/
-	$(Q) echo "Builds are reproducible"
-
-clean: clean_man
+clean:
+	cd lib/elixir && ../../$(REBAR) clean
 	rm -rf ebin
 	rm -rf lib/*/ebin
-	rm -rf $(PARSER)
-	rm -rf lib/*/_build/
-	rm -rf lib/*/tmp/
-	rm -rf lib/elixir/test/ebin/
-	rm -rf lib/mix/test/fixtures/deps_on_git_repo/
-	rm -rf lib/mix/test/fixtures/git_rebar/
-	rm -rf lib/mix/test/fixtures/git_repo/
-	rm -rf lib/mix/test/fixtures/git_sparse_repo/
-	rm -rf lib/mix/test/fixtures/archive/ebin/
-	rm -f erl_crash.dump
-	rm -rf cover
+	rm -rf lib/elixir/test/ebin
+	rm -rf lib/*/tmp
+	rm -rf lib/mix/test/fixtures/git_repo
+	rm -rf lib/mix/test/fixtures/deps_on_git_repo
+	rm -rf lib/mix/test/fixtures/git_rebar
+	rm -rf lib/elixir/src/elixir.app.src
 
-clean_elixir:
+clean_exbeam:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
 
-#==> Documentation tasks
+#==> Release tasks
 
-SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}")
-DOCS_COMPILE = 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)" --logo lib/elixir/pages/images/logo.png --output doc/$(2) --canonical "https://$(2).hexdocs.pm/$(CANONICAL)" --homepage-url "https://elixir-lang.org/docs.html" $(DOCS_OPTIONS) $(4)
-DOCS_CONFIG = bin/elixir lib/elixir/scripts/docs_config.exs "$(1)"
+SOURCE_REF = $(shell head="$$(git rev-parse HEAD)" tag="$$(git tag --points-at $$head | tail -1)" ; echo "$${tag:-$$head}\c")
+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)" -o docs/$(2) -p http://elixir-lang.org/docs.html
 
-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 DOCS_COMPILE,Elixir,elixir,Kernel,--config "lib/elixir/scripts/elixir_docs.exs")
-	$(call DOCS_CONFIG,elixir)
-
-docs_eex: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (eex)"
-	$(Q) rm -rf doc/eex
-	$(call DOCS_COMPILE,EEx,eex,EEx,--config "lib/elixir/scripts/mix_docs.exs")
-	$(call DOCS_CONFIG,eex)
-
-docs_mix: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (mix)"
-	$(Q) rm -rf doc/mix
-	$(call DOCS_COMPILE,Mix,mix,Mix,--config "lib/elixir/scripts/mix_docs.exs")
-	$(call DOCS_CONFIG,mix)
-
-docs_iex: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (iex)"
-	$(Q) rm -rf doc/iex
-	$(call DOCS_COMPILE,IEx,iex,IEx,--config "lib/elixir/scripts/mix_docs.exs")
-	$(call DOCS_CONFIG,iex)
-
-docs_ex_unit: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (ex_unit)"
-	$(Q) rm -rf doc/ex_unit
-	$(call DOCS_COMPILE,ExUnit,ex_unit,ExUnit,--config "lib/elixir/scripts/mix_docs.exs")
-	$(call DOCS_CONFIG,ex_unit)
-
-docs_logger: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (logger)"
-	$(Q) rm -rf doc/logger
-	$(call DOCS_COMPILE,Logger,logger,Logger,--config "lib/elixir/scripts/mix_docs.exs")
-	$(call DOCS_CONFIG,logger)
+docs: compile ../ex_doc/bin/ex_doc
+	$(Q) rm -rf docs
+	$(call DOCS,Elixir,elixir,Kernel)
+	$(call DOCS,EEx,eex,EEx)
+	$(call DOCS,Mix,mix,Mix)
+	$(call DOCS,IEx,iex,IEx)
+	$(call DOCS,ExUnit,ex_unit,ExUnit)
+	$(call DOCS,Logger,logger,Logger)
 
 ../ex_doc/bin/ex_doc:
-	@ echo "ex_doc is not found in ../ex_doc as expected. See CONTRIBUTING.md for more information."
+	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
 	@ false
 
-#==> Zip tasks
+release_zip: compile
+	rm -rf v$(VERSION).zip
+	zip -9 -r v$(VERSION).zip bin CHANGELOG.md LEGAL lib/*/ebin LICENSE Makefile README.md VERSION
 
-Docs.zip: docs
-	rm -f Docs.zip
-	zip -9 -r Docs.zip CHANGELOG.md doc LICENSE README.md
-	@ echo "Docs file created $(CURDIR)/Docs.zip"
+release_docs: docs
+	cd ../docs
+	rm -rf ../docs/master
+	mv docs ../docs/master
 
-Precompiled.zip: build_man compile
-	rm -f Precompiled.zip
-	zip -9 -r Precompiled.zip bin CHANGELOG.md lib/*/ebin lib/*/lib LICENSE Makefile man README.md VERSION
-	@ echo "Precompiled file created $(CURDIR)/Precompiled.zip"
+#==> Tests tasks
 
-#==> Test tasks
-
-test: test_formatted test_erlang test_elixir
-
-test_windows: test test_taskkill
-
-test_taskkill:
-	taskkill //IM erl.exe //F //T //FI "MEMUSAGE gt 0"
-	taskkill //IM epmd.exe //F //T //FI "MEMUSAGE gt 0"
+test: test_erlang test_elixir
 
 TEST_ERL = lib/elixir/test/erlang
 TEST_EBIN = lib/elixir/test/ebin
 TEST_ERLS = $(addprefix $(TEST_EBIN)/, $(addsuffix .beam, $(basename $(notdir $(wildcard $(TEST_ERL)/*.erl)))))
 
-define FORMAT
-	$(Q) if [ "$(OS)" = "Windows_NT" ]; then \
-		cmd //C call ./bin/mix.bat format $(1); \
-	else \
-		bin/elixir bin/mix format $(1); \
-	fi
-endef
-
-format: compile
-	$(call FORMAT)
-
-test_formatted: compile
-	$(call FORMAT,--check-formatted)
-
 test_erlang: compile $(TEST_ERLS)
 	@ echo "==> elixir (eunit)"
 	$(Q) $(ERL) -pa $(TEST_EBIN) -s test_helper test;
@@ -283,34 +166,29 @@ $(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_doc_test test_mix test_eex test_iex
+
+test_doc_test: compile
+	@ echo "==> doctest (exunit)"
+	$(Q) cd lib/elixir && ../../bin/elixir -r "test/doc_test.exs";
 
 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 --sname primary -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 --sname primary -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
 
-cover/ex_unit_elixir.coverdata:
-	$(Q) COVER="1" $(MAKE) test_stdlib
-cover/combined.coverdata: cover/ex_unit_elixir.coverdata
-
-cover/combined.coverdata:
-	bin/elixir ./lib/elixir/scripts/cover.exs
-
-cover: cover/combined.coverdata
-
 #==> Dialyzer tasks
 
-DIALYZER_OPTS = --no_check_plt --fullpath -Werror_handling -Wunmatched_returns -Wunderspecs
+DIALYZER_OPTS = --no_check_plt --fullpath -Werror_handling -Wunmatched_returns -Wrace_conditions -Wunderspecs
 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)
@@ -319,32 +197,4 @@ build_plt: clean_plt $(PLT)
 
 dialyze: compile $(PLT)
 	@ echo "==> Dialyzing Elixir..."
-	$(Q) dialyzer -pa lib/elixir/ebin --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin
-
-#==> Man page tasks
-
-build_man: man/iex.1 man/elixir.1
-
-define BUILD_MANPAGES
-man/$(APP).1:
-	$(Q) cp man/$(APP).1.in man/$(APP).1
-	$(Q) sed -i.bak "/{COMMON}/r man/common" man/$(APP).1
-	$(Q) sed -i.bak "/{COMMON}/d" man/$(APP).1
-	$(Q) rm -f man/$(APP).1.bak
-endef
-
-$(foreach APP, elixir iex, $(eval $(BUILD_MANPAGES)))
-
-clean_man:
-	rm -f man/elixir.1
-	rm -f man/elixir.1.bak
-	rm -f man/iex.1
-	rm -f man/iex.1.bak
-
-install_man: build_man
-	$(Q) mkdir -p $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(MAN_PREFIX)/man1
-	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(MAN_PREFIX)/man1
-	"$(MAKE)" clean_man
+	$(Q) dialyzer --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin

OPEN_SOURCE_POLICY.md

@@ -1,165 +0,0 @@
-<!--
-  SPDX-License-Identifier: Apache-2.0
-  SPDX-FileCopyrightText: 2021 The Elixir Team
--->
-
-# Open Source Policy
-
-## 1. Introduction
-
-This Open Source Policy outlines the licensing, contribution, and compliance
-requirements for all code released under the Elixir project. By adhering to
-these guidelines, we ensure that our community, maintainers, and contributors
-uphold both legal and ethical standards while fostering a collaborative,
-transparent environment.
-
-This policy exists to support and protect the Elixir community. It aims to
-balance openness, collaboration, and respect for all contributors’ rights,
-ensuring that Elixir remains a trusted and innovative open source project.
-
-## 2. Scope
-
-This policy applies to the Elixir Programming language, located at
-<https://github.com/elixir-lang/elixir>. It covers every file, and contribution
-made, including documentation and any associated assets.
-
-## 3. Licensing
-
-All code released by the Elixir team is licensed under the
-[Apache-2.0](./LICENSES/Apache-2.0.txt) license. Additionally, the following
-licenses are recognized as permissible in this project:
-
-  - The Unicode license, as documented at
-    [LicenseRef-scancode-unicode](./LICENSES/LicenseRef-scancode-unicode.txt)
-
-  - The Elixir Trademark Policy, as documented at
-    [LicenseRef-elixir-trademark-policy](./LICENSES/LicenseRef-elixir-trademark-policy.txt)
-
-These licenses are considered acceptable for any files or code that form part of
-an Elixir repository. If a contribution requires a different license, it must
-either be rejected or prompt an update to this policy.
-
-## 4. Contributing to the Elixir repository
-
-Any code contributed to the Elixir repository must fall under one of the accepted
-licenses (Apache-2.0, Unicode, or Elixir Trademark). Contributions under any
-other license will be rejected unless this policy is formally revised to include
-that license. All files except those specifically exempted (e.g., certain test
-fixture files) must contain SPDX license and copyright headers
-(`SPDX-License-Identifier` and `SPDX-FileCopyrightText`). If a file qualifies
-for an exception, this must be configured in the ORT (Open Source Review Toolkit)
-configuration and undergo review.
-
-Contributions must not introduce executable binary files into the codebase.
-
-## 5. Preservation of Copyright and License Information
-
-Any third-party code incorporated into the Elixir repository must retain original
-copyright and license headers. If no such headers exist in the source, they must
-be added. This practice ensures that original authors receive proper credit and
-that the licensing lineage is preserved.
-
-## 6. Objectives
-
-The Elixir project aims to promote a culture of responsible open source usage.
-Specifically, our objectives include:
-
-### 6.1 Clearly Define and Communicate Licensing & Compliance Policies
-
-We will identify and document all third-party dependencies, ensure that license
-information is communicated clearly, and maintain a project-wide license policy
-or compliance handbook.
-
-### 6.2 Implement Clear Processes for Reviewing Contributions
-
-We will provide well-defined contribution guidelines. We implement the
-Developer Certificate of Origin (DCO) for additional clarity regarding
-contributor rights and obligations.
-
-### 6.3 Track and Audit Third-Party Code Usage
-
-All projects will implement a Software Bill of Materials (SBoM) strategy and
-regularly verify license compliance for direct and transitive dependencies.
-
-### 6.4 Monitor and Continuously Improve Open Source Compliance
-
-We will conduct periodic internal audits, integrate compliance checks into
-continuous integration (CI/CD) pipelines, and regularly review and refine these
-objectives to align with best practices.
-
-## 7. Roles and Responsibilities
-
-### 7.1 Core Team Member
-
-Core Team Members are responsible for being familiar with this policy and
-ensuring it is consistently enforced. They must demonstrate sufficient
-competencies to understand the policy requirements and must reject or request
-changes to any pull requests that violate these standards.
-
-### 7.2 Contributor
-
-Contributors are expected to follow this policy when submitting code. If a
-contributor submits a pull request that does not comply with the policy
-(e.g., introduces a disallowed license), Core Team Members have the authority to
-reject it or request changes. No special competencies are required for
-contributors beyond awareness and adherence to the policy.
-
-### 7.3 EEF CISO
-
-The CISO designated by the Erlang Ecosystem Foundation (EEF) provides oversight
-on queries and guidance regarding open source compliance or legal matters for
-Elixir. The CISO is responsible for checking ongoing compliance with the policy,
-escalating potential violations to the Core Team, and involving legal counsel if
-necessary. This role does not require legal expertise but does involve
-initiating legal or community discussions when needed.
-
-## 8. Implications of Failing to Follow the Program Requirements
-
-If a violation of this policy is identified, the Elixir Core Team will undertake
-the following actions:
-
-## 8.1 Review the Codebase for Additional Violations
-
-We will investigate the codebase thoroughly to detect any similar instances of
-non-compliance.
-
-## 8.2 Review and Update the Process or Policy
-
-In collaboration with the EEF CISO, the Elixir Core Team will assess the policy
-and our internal workflows, making any necessary clarifications or amendments to
-reduce the likelihood of recurrence.
-
-## 8.3 Notify and Train Core Team Members
-
-We will ensure that all active Core Team Members are informed about any policy
-changes and understand how to apply them in everyday development.
-
-## 8.4 Remove or Replace the Offending Code
-
-If required, we will remove or replace the non-compliant code.
-
-## 9. Contact
-
-The project maintains a private mailing list at
-[policy@elixir-lang.org](mailto:policy@elixir-lang.org) for handling licensing
-and policy-related queries. Email is the preferred communication channel, and
-the EEF CISO will be included on this list to provide assistance and ensure
-timely responses. While solutions may take longer to implement, the project
-commits to acknowledging all queries within five business days.
-
-## 10. External Contributions of Core Team Members
-
-When Core Team Members contribute to repositories outside Elixir, they do so in
-a personal capacity or via their employer. They will not act as official
-representatives of the Elixir team in those external contexts.
-
-## 11. Policy Review and Amendments
-
-This policy will be revisited annually to address new concerns, accommodate
-changes in community standards, or adjust to emerging legal or technical
-requirements. Proposed amendments must be reviewed by the Core Team and, if
-necessary, by the EEF CISO. Any significant changes will be communicated to
-contributors and made publicly available.
-
-*Effective Date: 2025-02-20*  
-*Last Reviewed: 2025-11-20*

README.md

@@ -1,159 +1,59 @@
-<!--
-  SPDX-License-Identifier: Apache-2.0
-  SPDX-FileCopyrightText: 2021 The Elixir Team
-  SPDX-FileCopyrightText: 2012 Plataformatec
--->
+![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
+=========
+[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master "Build Status")](http://travis-ci.org/elixir-lang/elixir)
 
-<h1>
- <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://github.com/elixir-lang/elixir-lang.github.com/raw/main/images/logo/logo-dark.png">
-  <img alt="Elixir logo" src="https://github.com/elixir-lang/elixir-lang.github.com/raw/main/public/images/logo/logo.png" width="200">
- </picture>
-</h1>
+For more about Elixir, installation and documentation, [check Elixir's website](http://elixir-lang.org/).
 
-[![CI](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml?query=branch%3Amain)
-[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/10187/badge)](https://www.bestpractices.dev/projects/10187)
+## Usage
 
-Elixir is a programming language designed for building scalable
-and maintainable applications.
+If you want to contribute to Elixir or run it from source, clone this repository to your machine, compile and test it:
 
-For more about Elixir, installation and documentation,
-[check Elixir's website](https://elixir-lang.org/).
+    $ git clone https://github.com/elixir-lang/elixir.git
+    $ cd elixir
+    $ make clean test
 
-## Policies
+> Note: if you are running on Windows, [this article includes important notes for compiling Elixir from source on Windows](https://github.com/elixir-lang/elixir/wiki/Windows).
 
-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.
+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`.
 
-All security releases [will be tagged with `[security]`][10]. For more
-information, please read our [Security Policy][9].
+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.
 
-All interactions in our official communication channels follow our
-[Code of Conduct][1].
+However, if tests fail, it is likely you have an outdated Erlang version (Elixir requires Erlang 17.0 or later). You can check your Erlang version by calling `erl` in the command line. You will see some information as follows:
 
-All contributions are required to conform to our [Open Source Policy][11].
+    Erlang/OTP 17 [erts-6.0] [source-07b8f44] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false]
 
-## Bug reports
+If you have the correct version and tests still fail, feel free to [open an issue][2].
 
-For reporting bugs, [visit our issue tracker][2] and follow the steps
-for reporting a new issue. **Please disclose security vulnerabilities
-privately [in our Security page](https://github.com/elixir-lang/elixir/security)**.
+## Building documentation
 
-All currently open bugs related to Elixir 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.
+Building the documentation requires [ex_doc](https://github.com/elixir-lang/ex_doc) to be installed and built in the same containing folder as elixir.
 
-Our *actionable item policy* has some important consequences, such as:
-
-  * Proposing new features as well as requests for support, help, and
-    guidance must be done in their own spaces, detailed next.
-
-  * Issues we have identified to be outside of Elixir's scope,
-    such as an upstream bug, 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. If you believe we got something wrong, drop a
-    comment and we can always reopen the issue.
-
-By keeping the overall issues tracker tidy and organized, the community
-can easily peek at what is coming in new releases and also get involved
-by commenting on existing issues and submitting pull requests. Please
-remember to keep the tone positive and be kind! For more information,
-see the [Code of Conduct][1].
-
-## Discussions, support, and help
-
-For general discussions, support, and help, please use 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.
-
-## Proposing new features
-
-We encourage you to first propose new features in the community spaces
-listed above. These discussions help refine ideas and gather feedback before
-submission. Our website also includes [a general outline of the language
-history and its current development focus](https://elixir-lang.org/development.html).
-
-Once you are ready, you can submit your proposal to the [Elixir Core
-mailing list][3], either through the web interface or by subscribing to
-it at <elixir-lang-core+subscribe@googlegroups.com>. Remember to include
-a clear problem description, compare the proposed solution to existing
-alternatives in the Elixir ecosystem (and in other languages if possible),
-and consider the potential impact your changes will have on the codebase and
-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]
-before release.
-
-## 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:
-
-```sh
-git clone https://github.com/elixir-lang/elixir.git
-cd elixir
-make
-```
-
-> Note: if you are running on Windows,
-[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).
-
-When updating the repository, you may want to run `make clean` before
-recompiling. For deterministic builds, you should set the environment
-variable `ERL_COMPILER_OPTIONS=deterministic`.
+    # After cloning and compiling Elixir
+    $ git clone git://github.com/elixir-lang/ex_doc.git
+    $ cd ex_doc && ../elixir/bin/mix compile
+    $ cd ../elixir && make docs
 
 ## Contributing
 
-Contributions to Elixir are always welcome! Before you get started, please check
-out our [CONTRIBUTING.md](CONTRIBUTING.md) file. There you will find detailed
-guidelines on how to set up your environment, run the test suite, format your
-code, and submit pull requests.
+We appreciate any contribution to Elixir, so check out our [CONTRIBUTING.md](CONTRIBUTING.md) guide for more information. We usually keep a list of features and bugs [in the issue tracker][2].
 
-Note you must disclose the use of coding agents and AI written code in your
-contributions. See the "Using AI and coding agents" in [CONTRIBUTING.md](CONTRIBUTING.md).
+## Important links
 
-## Development links
+* \#elixir-lang on freenode IRC
+* [Website][1]
+* [Issue tracker][2]
+* [elixir-talk Mailing list (questions)][3]
+* [elixir-core Mailing list (development)][4]
 
-  * [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
-
-  [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
-  [11]: OPEN_SOURCE_POLICY.md
+  [3]: http://groups.google.com/group/elixir-lang-talk
+  [4]: http://groups.google.com/group/elixir-lang-core
 
 ## 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 with some parts under Erlang's license (EPL).
 
-Check [LICENSE](LICENSE) file for more information.
+Check [LEGAL](LEGAL) and [LICENSE](LICENSE) files for more information.

RELEASE.md

@@ -1,55 +1,31 @@
-<!--
-  SPDX-License-Identifier: Apache-2.0
-  SPDX-FileCopyrightText: 2021 The Elixir Team
-  SPDX-FileCopyrightText: 2012 Plataformatec
--->
-
 # Release process
 
-## Shipping a new version
+This document simply outlines the release process:
 
-1. Update version in /VERSION, bin/elixir, and bin/elixir.bat
+1. Remove all `-dev` extension from versions (see below for all files)
 
-2. Ensure /CHANGELOG.md is updated, versioned and add the current date
+2. Ensure CHANGELOG is updated and add current date
 
-3. Update "Compatibility and Deprecations" if a new OTP version is supported
+3. Commit changes above with title "Release vVERSION" and generate new tag
 
-4. Commit changes above with title "Release vVERSION" and push it
+4. Run `make clean test` to ensure all tests pass from scratch and the CI is green
 
-5. Once GitHub actions completes, generate a new tag, and push it
+5. Push master and the new tag
 
-6. Wait until GitHub Actions publish artifacts to the draft release
+6. Release new docs with `make release_docs`, move docs to `docs/stable`
 
-7. Copy the relevant bits from /CHANGELOG.md to the GitHub release and publish it (link to the announcement if there is one)
+7. Release new zip with `make release_zip`, push new zip to GitHub Releases, name it `Precompiled.zip`
 
-8. Update `_data/elixir-versions.yml` (except for RCs) in `elixir-lang/elixir-lang.github.com`
+8. Fast-forward merge master into stable branch with `git merge master --ff` and push it
 
-## Creating a new vMAJOR.MINOR branch (usually before first rc)
+9. After release, bump versions, add `-dev` back and commit
 
-### In the new branch
+10. `make release_docs` once again and push it to `elixir-lang/docs`
 
-1. Comment out `CANONICAL := main/` in /Makefile
+11. Add the release to `elixir.csv` file in `elixir-lang/elixir-lang.github.com`
 
-2. Update tables in /SECURITY.md and "Compatibility and Deprecations"
+## Places where version is mentioned
 
-3. Commit "Branch out vMAJOR.MINOR"
-
-### 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 relevant CI workflows in `/.github/workflows/*.yml` - for release workflows, outdated/recently added Erlang/OTP versions must run conditionally
-
-4. Remove `otp_release` version checks that are no longer needed
+* VERSION (make sure there is no newline in this file)
+* CHANGELOG.md
+* src/elixir.app.src (not lib/elixir/src/elixir.app.src)

SECURITY.md

@@ -1,30 +0,0 @@
-<!--
-  SPDX-License-Identifier: Apache-2.0
-  SPDX-FileCopyrightText: 2021 The Elixir Team
-  SPDX-FileCopyrightText: 2012 Plataformatec
--->
-
-# 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.21           | Development
-1.20           | Bug fixes and security patches
-1.19           | Security patches only
-1.18           | Security patches only
-1.17           | Security patches only
-1.16           | 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).
-
-You may also see [all releases](https://github.com/elixir-lang/elixir/releases) and [consult all disclosed vulnerabilities](https://github.com/elixir-lang/elixir/security) on GitHub.
-
-## Reporting a vulnerability
-
-[Please disclose security vulnerabilities privately via GitHub](https://github.com/elixir-lang/elixir/security).

VERSION

@@ -1 +1 @@
-1.21.0-dev
+1.0.0-rc1

bin/elixir

@@ -1,68 +1,26 @@
 #!/bin/sh
+if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+  echo "Usage: `basename $0` [options] [.exs file] [data]
 
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
+  -v                Prints version and exit
+  -e \"command\"      Evaluates the given command (*)
+  -r \"file\"         Requires the given files/patterns (*)
+  -S \"script\"       Finds and executes the given script
+  -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 (*)
+  --app \"app\"       Start the given app and its dependencies (*)
+  --erl \"switches\"  Switches to be passed down to erlang (*)
+  --name \"name\"     Makes and assigns a name to the distributed node
+  --sname \"name\"    Makes and assigns a short name to the distributed node
+  --cookie \"cookie\" Sets a cookie for this distributed node
+  --hidden          Makes a hidden node
+  --detached        Starts the Erlang VM detached from console
+  --no-halt         Does not halt the Erlang VM after execution
 
-set -e
-
-ELIXIR_VERSION=1.21.0-dev
-
-if [ $# -eq 0 ] || { [ $# -eq 1 ] && { [ "$1" = "--help" ] || [ "$1" = "-h" ]; }; }; then
-  cat <<USAGE >&2
-Usage: $(basename "$0") [options] [.exs file] [data]
-
-## 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)
-
-  --color, --no-color          Enables or disables ANSI coloring
-  --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)
-
-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
-
---name and --sname may be set to undefined so one is automatically generated.
-
-## 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
 
@@ -72,175 +30,71 @@ 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)
+MODE="elixir"
 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="cli"
 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
-    +elixirc)
-        C=1
-        ;;
+while [ $I -le $# ]; do
+  S=1
+  eval "PEEK=\${$I}"
+  case "$PEEK" in
     +iex)
-        C=1
         MODE="iex"
         ;;
-    -v|--no-halt|--color|--no-color)
-        C=1
+    +elixirc)
+        MODE="elixirc"
         ;;
-    -e|-r|-pr|-pa|-pz|--eval|--remsh|--dot-iex|--dbg)
-        C=2
+    -v|--compile|--no-halt)
         ;;
-    --rpc-eval)
-        C=3
-        ;;
-    --hidden)
-        S=1
-        ERL="$ERL -hidden"
-        ;;
-    --logger-otp-reports)
+    -e|-r|-pr|-pa|-pz|--remsh|--app)
         S=2
-        if [ "$2" = 'true' ] || [ "$2" = 'false' ]; then
-          ERL="$ERL -logger handle_otp_reports $2"
-        fi
         ;;
-    --logger-sasl-reports)
-        S=2
-        if [ "$2" = 'true' ] || [ "$2" = 'false' ]; then
-          ERL="$ERL -logger handle_sasl_reports $2"
-        fi
-        ;;
-    --erl)
-        S=2
-        ERL="$ERL $2"
+    --detached|--hidden)
+        ERL="$ERL `echo $PEEK | cut -c 2-`"
         ;;
     --cookie)
-        S=2
-        erl_set "-setcookie"
-        erl_set "$2"
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL -setcookie "$VAL""
         ;;
     --sname|--name)
-        S=2
-        erl_set "$(echo "$1" | cut -c 2-)"
-        erl_set "$2"
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL `echo $PEEK | cut -c 2-` "$VAL""
         ;;
-    --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
+    --erl)
+        I=$(expr $I + 1)
+        eval "VAL=\${$I}"
+        ERL="$ERL "$VAL""
         ;;
     *)
-        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")
 SCRIPT_PATH=$(dirname "$SELF")
 
-if [ "$OSTYPE" = "cygwin" ]; then SCRIPT_PATH=$(cygpath -m "$SCRIPT_PATH"); fi
-if [ "$MODE" != "iex" ]; then ERL="-s elixir start_cli $ERL"; fi
+if [ "$OSTYPE" = "cygwin" ]; then SCRIPT_PATH=$(cygpath -m "SCRIPT_PATH"); fi
+if [ "$MODE" != "iex" ]; then ERL="-noshell -s elixir start_cli $ERL"; 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" -noshell -elixir_root "$SCRIPT_PATH"/../lib -pa "$SCRIPT_PATH"/../lib/elixir/ebin $ELIXIR_ERL_OPTIONS $ERL "$@"
-
-if [ -n "$RUN_ERL_PIPE" ]; then
-  ESCAPED=""
-  for PART in "$@"; do
-    ESCAPED="$ESCAPED $(printf '%s' "$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"
+# 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
 
-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
+  else
+    ERL_PATH=erl
+  fi
 fi
+
+exec "$ERL_PATH" -pa "$SCRIPT_PATH"/../lib/*/ebin $ELIXIR_ERL_OPTIONS $ERL -extra "$@"

bin/elixir.bat

@@ -1,149 +1,106 @@
 @echo off
-
-:: SPDX-License-Identifier: Apache-2.0
-:: SPDX-FileCopyrightText: 2021 The Elixir Team
-:: SPDX-FileCopyrightText: 2012 Plataformatec
-
-set ELIXIR_VERSION=1.21.0-dev
-
-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 "%1"=="--help" goto documentation
+if "%1"=="-h"     goto documentation
+if "%1"=="/h"     goto documentation
 goto parseopts
 
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo ## General options
+echo   -v                Prints version and exit
+echo   -e command        Evaluates the given command (*)
+echo   -r file           Requires the given files/patterns (*)
+echo   -S script         Finds and executes the given script
+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   --app app         Start the given app and its dependencies (*)
+echo   --erl switches    Switches to be passed down to erlang (*)
+echo   --name name       Makes and assigns a name to the distributed node
+echo   --sname name      Makes and assigns a short name to the distributed node
+echo   --cookie cookie   Sets a cookie for this distributed node
+echo   --hidden          Makes a hidden node
+echo   --detached        Starts the Erlang VM detached from console
+echo   --werl            Uses Erlang's Windows shell GUI
+echo   --no-halt         Does not halt the Erlang VM after execution
 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.
-echo   --color, --no-color          Enables or disables ANSI coloring
-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.
-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 --name and --sname may be set to undefined so one is automatically generated.
-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
-setlocal enabledelayedexpansion
 
 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 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 Designates which mode / Elixir component to run as
+set runMode="elixir"
 
 rem Recursive loop called for each parameter that parses the cmd line parameters
 :startloop
-set "par=%~1"
-if "!par!"=="" (
-  rem skip if no parameter
-  goto run
-)
+set par="%1"
 shift
-set par="!par:"=\"!"
+if "%par%"=="" (
+  rem if no parameters defined
+  goto :expand_erl_libs
+)
+if "%par%"=="""" (
+  rem if no parameters defined - special case for parameter that is already quoted
+  goto :expand_erl_libs
+)
 rem ******* EXECUTION OPTIONS **********************
-if !par!=="+iex"     (set useIEx=1 && goto startloop)
-if !par!=="+elixirc" (goto startloop)
-rem ******* ELIXIR PARAMETERS **********************
-if ""==!par:-e=!          (shift && goto startloop)
-if ""==!par:--eval=!      (shift && goto startloop)
-if ""==!par:--rpc-eval=!  (shift && shift && goto startloop)
-if ""==!par:-r=!          (shift && goto startloop)
-if ""==!par:-pr=!         (shift && goto startloop)
-if ""==!par:-pa=!         (shift && goto startloop)
-if ""==!par:-pz=!         (shift && goto startloop)
-if ""==!par:-v=!          (goto startloop)
-if ""==!par:--version=!   (goto startloop)
-if ""==!par:--no-halt=!   (goto startloop)
-if ""==!par:--color=!     (goto startloop)
-if ""==!par:--no-color=!  (goto startloop)
-if ""==!par:--remsh=!     (shift && goto startloop)
-if ""==!par:--dot-iex=!   (shift && goto startloop)
-if ""==!par:--dbg=!       (shift && goto startloop)
+IF "%par%"==""--werl"" (Set useWerl=1)
+IF "%par%"==""+iex"" (Set runMode="iex")
+rem ******* elixir parameters **********************
+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:--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)
+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:--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 ********************
+SETLOCAL enabledelayedexpansion
+set ext_libs=
+for  /d %%d in ("%originPath%..\lib\*.") do (
+  set ext_libs=!ext_libs! -pa "%%~fd\ebin"
+)
+SETLOCAL disabledelayedexpansion
 :run
-setlocal disabledelayedexpansion
-if not defined useIEx (
+IF NOT %runMode% == "iex" (
   set beforeExtra=-s elixir start_cli %beforeExtra%
 )
-
-set beforeExtra=-noshell -elixir_root "%SCRIPT_PATH%..\lib" -pa "%SCRIPT_PATH%..\lib\elixir\ebin" %beforeExtra%
-
-if defined ELIXIR_CLI_DRY_RUN (
-  echo "%ERTS_BIN%erl.exe" %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
-) else (
-  "%ERTS_BIN%erl.exe" %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
+IF %useWerl% EQU 1 (
+  start werl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
+) ELSE (
+  erl.exe %ext_libs% -noshell %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 )
-exit /B %ERRORLEVEL%
 :end
 endlocal

bin/elixirc

@@ -1,30 +1,17 @@
 #!/bin/sh
-
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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)
+  -o               The directory to output compiled files
+  --no-docs        Do not attach documentation to compiled modules
+  --no-debug-info  Do not attach debug info to compiled modules
+  --ignore-module-conflict
+  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  --verbose        Print informational messages.
 
-  --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
-
-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
 
@@ -34,7 +21,7 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 

bin/elixirc.bat

@@ -1,17 +1,10 @@
 @echo off
-
-:: SPDX-License-Identifier: Apache-2.0
-:: SPDX-FileCopyrightText: 2021 The Elixir Team
-:: SPDX-FileCopyrightText: 2012 Plataformatec
-
-setlocal
 set argc=0
 for %%A in (%*) do (
-  if /I "%%A"=="--help" goto documentation
-  if /I "%%A"=="-h"     goto documentation
-  if /I "%%A"=="/h"     goto documentation
-  if    "%%A"=="/?"     goto documentation
-  set /A argc+=1
+    if "%%A"=="--help" goto documentation
+    if "%%A"=="-h"     goto documentation
+    if "%%A"=="/h"     goto documentation
+    set /A argc+=1
 )
 if %argc%==0 goto documentation
 goto run
@@ -19,24 +12,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   --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  -o               The directory to output compiled files
+echo  --no-docs        Do not attach documentation to compiled modules
+echo  --no-debug-info  Do not attach debug info to compiled modules
+echo  --ignore-module-conflict
+echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  --verbose        Print informational messages.
 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
-echo ** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS
-goto end
-
+echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS
+echo ** Options can be passed to the erlang compiler using ERL_COMPILER_OPTIONS >&2
 :run
 call "%~dp0\elixir.bat" +elixirc %*
-
-:end
-endlocal

bin/iex

@@ -1,25 +1,28 @@
 #!/bin/sh
+if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
+  echo "Usage: `basename $0` [options] [.exs file] [data]
 
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
+  -v                Prints version
+  -e \"command\"      Evaluates the given command (*)
+  -r \"file\"         Requires the given files/patterns (*)
+  -S \"script\"       Finds and executes the given script
+  -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 (*)
+  --app \"app\"       Start the given app and its dependencies (*)
+  --erl \"switches\"  Switches to be passed down to erlang (*)
+  --name \"name\"     Makes and assigns a name to the distributed node
+  --sname \"name\"    Makes and assigns a short name to the distributed node
+  --cookie \"cookie\" Sets a cookie for this distributed node
+  --hidden          Makes a hidden node
+  --detached        Starts the Erlang VM detached from console
+  --remsh \"name\"    Connects to a node using a remote shell
+  --dot-iex \"path\"  Overrides default .iex.exs file and uses path instead;
+                    path can be empty, then no file will be loaded
 
-set -e
-
-if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  cat <<USAGE >&2
-Usage: $(basename "$0") [options] [.exs file] [data]
-
-The following options are exclusive to IEx:
-
-  --dbg pry           Sets the backend for Kernel.dbg/2 to IEx.pry/0
-  --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.
-
-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
 
@@ -29,10 +32,12 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "$(pwd -P)/$filename"
+    echo "`pwd -P`/$filename"
   fi
 }
 
 SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
-exec "$SCRIPT_PATH"/elixir --no-halt --erl "-user elixir" +iex "$@"
+
+if [ "$OS" = "Windows_NT" ]; then NOSHELL="-noshell "; fi
+exec "$SCRIPT_PATH"/elixir --no-halt --erl "$NOSHELL -user Elixir.IEx.CLI" +iex "$@"

bin/iex.bat

@@ -1,31 +1,2 @@
 @echo off
-
-:: SPDX-License-Identifier: Apache-2.0
-:: SPDX-FileCopyrightText: 2021 The Elixir Team
-:: SPDX-FileCopyrightText: 2012 Plataformatec
-
-setlocal
-if /I ""%1""==""--help"" goto documentation
-if /I ""%1""==""-h""     goto documentation
-if /I ""%1""==""/h""     goto documentation
-if    ""%1""==""/?""     goto documentation
-goto run
-
-:documentation
-echo Usage: %~nx0 [options] [.exs file] [data]
-echo.
-echo The following options are exclusive to IEx:
-echo.
-echo   --dbg pry           Sets the backend for Kernel.dbg/2 to IEx.pry/0
-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.
-echo It accepts all other options listed by "elixir --help".
-goto end
-
-:run
-call "%~dp0\elixir.bat" --no-halt --erl "-user elixir" +iex %*
-:end
-endlocal
+call "%~dp0\elixir.bat" +iex --erl "-user Elixir.IEx.CLI" --no-halt %*

bin/mix

@@ -1,7 +1,4 @@
 #!/usr/bin/env elixir
-
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-Mix.CLI.main()
+# Reminder: apply any changes in this file to bin\mix.bat
+Mix.start
+Mix.CLI.main

bin/mix.bat

@@ -1,7 +1,2 @@
 @echo off
-
-:: SPDX-License-Identifier: Apache-2.0
-:: SPDX-FileCopyrightText: 2021 The Elixir Team
-:: SPDX-FileCopyrightText: 2012 Plataformatec
-
-call "%~dp0\elixir.bat" "%~dp0\mix" %*
+call "%~dp0\elixir.bat" -e Mix.start -e Mix.CLI.main %*

bin/mix.ps1

@@ -1,7 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 # Store path to mix.bat as a FileInfo object
 $mixBatPath = (Get-ChildItem (((Get-ChildItem $MyInvocation.MyCommand.Path).Directory.FullName) + '\mix.bat'))
 $newArgs = @()
@@ -24,4 +20,4 @@ for ($i = 0; $i -lt $args.length; $i++)
 }
 
 # Corrected arguments are ready to pass to batch file
-& $mixBatPath $newArgs
+& $mixBatPath $newArgs

lib/eex/lib/eex.ex

@@ -1,88 +1,43 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule EEx.SyntaxError do
-  defexception [:file, :line, :column, :snippet, message: "syntax error"]
-
-  @impl true
-  def message(exception) do
-    %{file: file, line: line, column: column, message: message, snippet: snippet} = exception
-
-    Exception.format_file_line_column(file && Path.relative_to_cwd(file), line, column, " ") <>
-      message <> (snippet || "")
-  end
+  defexception [:message]
 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 accepts 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`.
-
-    * `:engine` - the EEx engine to be used for compilation. Defaults to `EEx.SmartEngine`.
-
-    * `: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:
-
-      <%| ... %>
-      <%/ ... %>
+      file the template is read from or to "nofile" when compiling from a string.
+    * `:engine` - the EEx engine to be used for compilation.
 
   ## Engine
 
@@ -92,76 +47,73 @@ 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 a macro, there are no exceptions for this rule.
+  For example, while some template languages would special-
+  case `if` 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:
+  In other words, `<%= @foo %>` is simply translated to:
 
-      <%= {:ok, v} = Access.fetch(assigns, :foo); v %>
+      <%= Dict.get assigns, :foo %>
 
-  The `assigns` extension is useful when the number of variables
+  The assigns extension is useful when the number of variables
   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}
-
-  @type tokenize_opt ::
-          {:file, binary()}
-          | {:line, line}
-          | {:column, column}
-          | {:indentation, non_neg_integer}
-          | {:trim, boolean()}
-
-  @type compile_opt ::
-          tokenize_opt
-          | {:engine, module()}
-          | {:parser_options, Code.parser_opts()}
-          | {atom(), term()}
-
   @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).
-  Additional options are passed to the underlying engine.
+  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
-    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)
+  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(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
@@ -169,17 +121,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
@@ -188,184 +135,80 @@ 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)
+    quote bind_quoted: binding do
+      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
+  Get 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(), [compile_opt]) :: Macro.t()
-  def compile_string(source, options \\ []) when is_binary(source) and is_list(options) do
-    tokenize_opts = Keyword.take(options, [:file, :line, :column, :indentation, :trim])
-
-    case tokenize(source, tokenize_opts) do
-      {:ok, tokens} ->
-        EEx.Compiler.compile(tokens, source, options)
-
-      {:error, message, %{column: column, line: line}} ->
-        file = options[:file] || "nofile"
-        raise EEx.SyntaxError, file: file, line: line, column: column, message: message
-    end
+  def compile_string(source, options \\ []) do
+    EEx.Compiler.compile(source, options)
   end
 
   @doc """
-  Gets a `filename` and generates a quoted expression
+  Get 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(), [compile_opt]) :: 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)
+  def compile_file(filename, 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).
+  Get a string `source` and evaluate the values using the `bindings`.
 
   ## Examples
 
-      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
       "foo baz"
 
   """
-  @spec eval_string(String.t(), Code.binding(), [compile_opt]) :: term()
-  def eval_string(source, bindings \\ [], options \\ [])
-      when is_binary(source) and is_list(bindings) and is_list(options) do
+  def eval_string(source, bindings \\ [], options \\ []) do
     compiled = compile_string(source, options)
     do_eval(compiled, bindings, options)
   end
 
   @doc """
-  Gets a `filename` and evaluate the values using the `bindings`.
-
-  The supported `options` are described [in the module docs](#module-options).
+  Get a `filename` and evaluate the values using the `bindings`.
 
   ## Examples
 
-      # sample.eex
+      # sample.ex
       foo <%= bar %>
 
-      # IEx
-      EEx.eval_file("sample.eex", bar: "baz")
-      #=> "foo baz"
+      # iex
+      EEx.eval_file "sample.ex", [bar: "baz"] #=> "foo baz"
 
   """
-  @spec eval_file(Path.t(), Code.binding(), [compile_opt]) :: String.t()
-  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)
+  def eval_file(filename, bindings \\ [], 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(~c"foo", line: 1, column: 1)
-      {:ok, [{:text, ~c"foo", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
-
-  ## Result
-
-  It returns `{:ok, [token]}` where a token is one of:
-
-    * `{:comment, content, %{column: column, line: line}}`
-    * `{: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([char()] | String.t(), [tokenize_opt]) ::
-          {: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
-    options = Keyword.take(options, [:file, :line, :module, :prune_binding])
     {result, _} = Code.eval_quoted(compiled, bindings, options)
     result
   end

lib/eex/lib/eex/compiler.ex

@@ -1,514 +1,101 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule EEx.Compiler do
   @moduledoc false
 
   # 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), contents, opts)
-  end
-
-  def tokenize(contents, opts) when is_list(contents) do
-    tokenize(contents, List.to_string(contents), opts)
-  end
-
-  def tokenize(contents, source, 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, source: source}
-
-    {contents, line, column} =
-      (trim && trim_init(contents, line, column, state)) || {contents, line, column}
-
-    tokenize(contents, line, column, state, [{line, column}], [])
-  end
-
-  defp tokenize(~c"<%%" ++ t, line, column, state, buffer, acc) do
-    tokenize(t, line, column + 3, state, [?%, ?< | buffer], acc)
-  end
-
-  defp tokenize(~c"<%!--" ++ t, line, column, state, buffer, acc) do
-    case comment(t, line, column + 5, state, []) do
-      {:error, message} ->
-        meta = %{line: line, column: column}
-        {:error, message <> code_snippet(state.source, state.indentation, meta), meta}
-
-      {: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: Remove me on Elixir v2.0
-  defp tokenize(~c"<%#" ++ t, line, column, state, buffer, acc) do
-    IO.warn("<%# is deprecated, use <%!-- or add a space between <% and # instead",
-      line: line,
-      column: column,
-      file: state.file
-    )
-
-    case expr(t, line, column + 3, state, []) do
-      {:error, 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(~c"<%" ++ t, line, column, state, buffer, acc) do
-    {marker, t} = retrieve_marker(t)
-    marker_length = length(marker)
-
-    case expr(t, line, column + 2 + marker_length, state, []) do
-      {:error, message} ->
-        meta = %{line: line, column: column}
-        {:error, message <> code_snippet(state.source, state.indentation, meta), meta}
-
-      {:ok, expr, new_line, new_column, rest} ->
-        {key, expr, extra_meta} =
-          case :elixir_tokenizer.tokenize(expr, 1, file: "eex", check_terminators: false) do
-            {:ok, _line, _column, _warnings, rev_tokens, []} ->
-              # We ignore warnings because the code will be tokenized
-              # again later with the right line+column info
-              token_key(rev_tokens, expr)
-
-            {:error, _, _, _, _} ->
-              {:expr, expr, %{}}
-          end
-
-        marker =
-          if key in [:middle_expr, :end_expr] and marker != ~c"" do
-            message =
-              "unexpected beginning of EEx tag \"<%#{marker}\" on \"<%#{marker}#{expr}%>\", " <>
-                "please remove \"#{marker}\""
-
-            IO.warn(message, file: state.file, line: line, column: column)
-            ~c""
-          else
-            marker
-          end
-
-        token = {key, marker, expr, Map.merge(%{line: line, column: column}, extra_meta)}
-        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &merge_token(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
-
-  # Merge middle expressions separated only by whitespace so the whitespace is
-  # part of the Elixir expression, not a separate EEx body.
-  defp merge_token(
-         {:middle_expr, ~c"", chars, meta},
-         [{:text, text, text_meta}, {:middle_expr, ~c"", prev_chars, prev_meta} | acc]
-       ) do
-    if only_spaces?(text) and clause_block_identifier?(prev_meta) do
-      [{:middle_expr, ~c"", prev_chars ++ text ++ chars, prev_meta} | acc]
-    else
-      [
-        {:middle_expr, ~c"", chars, meta},
-        {:text, text, text_meta},
-        {:middle_expr, ~c"", prev_chars, prev_meta} | acc
-      ]
-    end
-  end
-
-  defp merge_token(token, acc) do
-    [token | acc]
-  end
-
-  # Retrieve marker for <%
-
-  defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do
-    {[marker], t}
-  end
-
-  defp retrieve_marker(t) do
-    {~c"", 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, "expected closing '--%>' for EEx expression"}
-  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, "expected closing '%>' for EEx expression"}
-  end
-
-  # Receives tokens and check if it is a start, middle or an end token.
-  defp token_key(rev_tokens, expr) do
-    case {Enum.reverse(rev_tokens), drop_eol(rev_tokens)} do
-      {[{:end, _} | _], [{:do, _} | _]} ->
-        {:middle_expr, expr, %{}}
-
-      {_, [{:do, _} | _]} ->
-        {:start_expr, maybe_append_space(expr), %{}}
-
-      {_, [{:block_identifier, _, identifier} | _]} ->
-        {:middle_expr, maybe_append_space(expr), %{block_identifier: identifier}}
-
-      {[{:end, _} | _], [{:stab_op, _, _} | _]} ->
-        {:middle_expr, expr, %{}}
-
-      {_, [{:stab_op, _, _} | rev_tokens]} ->
-        if fn_before_end?(rev_tokens) 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 fn_before_end?([{:fn, _} | _]), do: true
-  defp fn_before_end?([{:end, _} | _]), do: false
-  defp fn_before_end?([_ | rev_tokens]), do: fn_before_end?(rev_tokens)
-  defp fn_before_end?([]), do: false
-
-  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()], String.t(), keyword) :: Macro.t()
-  def compile(tokens, source, opts) do
-    file = opts[:file] || "nofile"
-    line = opts[:line] || 1
-    indentation = opts[:indentation] || 0
-    parser_options = opts[:parser_options] || Code.get_compiler_option(:parser_options)
-    engine = opts[:engine] || @default_engine
-
-    state = %{
-      engine: engine,
-      file: file,
-      source: source,
-      line: line,
-      quoted: %{},
-      parser_options: [indentation: indentation] ++ parser_options,
-      indentation: indentation
-    }
-
-    init = state.engine.init(opts)
-
-    if function_exported?(state.engine, :handle_text, 2) and
-         not function_exported?(state.engine, :handle_text, 3) do
-      IO.warn(
-        "#{inspect(state.engine)}.handle_text/2 is deprecated, implement handle_text/3 instead"
-      )
-    end
-
-    generate_buffer(tokens, init, [], state)
+  def compile(source, opts) do
+    file   = opts[:file] || "nofile"
+    line   = opts[:line] || 1
+    tokens = EEx.Tokenizer.tokenize(source, line)
+    state  = %{engine: opts[:engine] || @default_engine,
+               file: file, line: line, quoted: [], start_line: nil}
+    generate_buffer(tokens, "", [], state)
   end
 
-  # Ignore tokens related to comment.
-  defp generate_buffer([{:comment, _chars, _meta} | rest], buffer, scope, state) do
-    generate_buffer(rest, buffer, scope, state)
+  # Generates the buffers by handling each expression from the tokenizer
+
+  defp generate_buffer([{:text, chars}|t], buffer, scope, state) do
+    buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
+    generate_buffer(t, buffer, scope, state)
   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: Remove this on Elixir v2.0. The deprecation is on init.
-        state.engine.handle_text(buffer, IO.chardata_to_string(chars))
-      end
-
-    generate_buffer(rest, buffer, scope, state)
+  defp generate_buffer([{:expr, line, mark, chars}|t], buffer, scope, state) do
+    expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
+    buffer = state.engine.handle_expr(buffer, mark, expr)
+    generate_buffer(t, 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)
-    buffer = handle_expr(buffer, mark, expr, meta, state)
-    generate_buffer(rest, buffer, scope, state)
+  defp generate_buffer([{:start_expr, start_line, mark, chars}|t], buffer, scope, state) do
+    {contents, line, t} = look_ahead_text(t, start_line, chars)
+    {contents, t} = generate_buffer(t, "", [contents|scope],
+                                    %{state | quoted: [], line: line, start_line: start_line})
+    buffer = state.engine.handle_expr(buffer, mark, contents)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer(
-         [{:start_expr, mark, chars, meta} | rest],
-         buffer,
-         scope,
-         state
-       ) do
-    {rest, line, contents} = look_ahead_middle(rest, meta.line, chars) || {rest, meta.line, chars}
-    start_line = meta.line
-    start_column = column(meta.column, mark)
-
-    {contents, rest} =
-      generate_buffer(
-        rest,
-        state.engine.handle_begin(buffer),
-        [{contents, start_line, start_column} | scope],
-        %{state | quoted: %{}, line: line}
-      )
-
-    if mark == ~c"" and not match?({:=, _, [_, _]}, contents) do
-      message =
-        "the contents of this expression won't be output unless the EEx block starts with \"<%=\""
-
-      IO.warn(message, file: state.file, line: meta.line, column: meta.column)
-    end
-
-    buffer = handle_expr(buffer, mark, contents, meta, state)
-    generate_buffer(rest, buffer, scope, state)
+  defp generate_buffer([{:middle_expr, line, _, chars}|t], buffer, [current|scope], state) do
+    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
+    generate_buffer(t, "", [wrapped|scope], %{state | line: line})
   end
 
-  defp generate_buffer(
-         [{:middle_expr, ~c"", chars, meta} | rest],
-         buffer,
-         [{current, current_line, current_column} | 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, current_line, current_column} | scope],
-      state
-    )
-  end
-
-  defp generate_buffer([{:middle_expr, _, chars, meta} | _tokens], _buffer, [], state) do
-    message = "unexpected middle of expression <%#{chars}%>"
-    syntax_error!(message, meta, state)
-  end
-
-  defp generate_buffer(
-         [{:end_expr, ~c"", chars, meta} | rest],
-         buffer,
-         [{current, line, column} | _],
-         state
-       ) do
-    {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)
-    options = [file: state.file, line: line, column: column] ++ state.parser_options
-    tuples = Code.string_to_quoted!(:lists.flatten(wrapped), options)
+  defp generate_buffer([{:end_expr, line, _, chars}|t], buffer, [current|_], state) do
+    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
+    tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
     buffer = insert_quoted(tuples, state.quoted)
-    {buffer, rest}
+    {buffer, t}
   end
 
-  defp generate_buffer([{:end_expr, _, chars, meta} | _], _buffer, [], state) do
-    message = "unexpected end of expression <%#{chars}%>"
-    syntax_error!(message, meta, state)
+  defp generate_buffer([{:end_expr, line, _, chars}|_], _buffer, [], _state) do
+    raise EEx.SyntaxError, message: "unexpected token: #{inspect chars} at line #{inspect line}"
   end
 
-  defp generate_buffer([{:eof, _meta}], buffer, [], state) do
+  defp generate_buffer([], buffer, [], state) do
     state.engine.handle_body(buffer)
   end
 
-  defp generate_buffer([{:eof, _meta}], _buffer, [{content, line, column} | _scope], state) do
-    message = "expected a closing '<% end %>' for block expression in EEx"
-    expr_meta = non_whitespace_meta(:lists.flatten(content), line, column, state)
-    syntax_error!(message, expr_meta, state)
+  defp generate_buffer([], _buffer, _scope, _state) do
+    raise EEx.SyntaxError, message: "unexpected end of string. expecting a closing <% end %>."
   end
 
-  defp non_whitespace_meta([space | rest], line, column, state) when space in @h_spaces,
-    do: non_whitespace_meta(rest, line, column + 1, state)
-
-  defp non_whitespace_meta([?\n | rest], line, _column, state),
-    do: non_whitespace_meta(rest, line + 1, state.indentation + 1, state)
-
-  defp non_whitespace_meta(_, line, column, _),
-    do: %{line: line, column: column}
-
   # Creates a placeholder and wrap it inside the expression block
 
   defp wrap_expr(current, line, buffer, chars, state) do
     new_lines = List.duplicate(?\n, line - state.line)
-    key = map_size(state.quoted)
-    placeholder = [~c"__EEX__(", Integer.to_charlist(key), ~c");"]
-    count = [current, placeholder, new_lines, chars]
-    new_state = %{state | quoted: Map.put(state.quoted, key, state.engine.handle_end(buffer))}
-
-    {count, new_state}
+    key = length(state.quoted)
+    placeholder = '__EEX__(' ++ Integer.to_char_list(key) ++ ');'
+    {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}|t]=list, start, contents) do
     if only_spaces?(text) do
-      look_ahead_middle(rest, start, contents ++ text)
+      {contents ++ text ++ chars, line, t}
     else
-      nil
+      {contents, start, list}
     end
   end
 
-  defp look_ahead_middle([{:middle_expr, _, chars, meta} | rest], _start, contents) do
-    {rest, meta.line, contents ++ chars}
-  end
-
-  defp look_ahead_middle(_tokens, _start, _contents) do
-    nil
+  defp look_ahead_text(t, start, contents) do
+    {contents, start, t}
   end
 
   defp only_spaces?(chars) do
-    Enum.all?(chars, &(&1 in @all_spaces))
+    Enum.all?(chars, &(&1 in [?\s, ?\t, ?\r, ?\n]))
   end
 
-  defp clause_block_identifier?(%{block_identifier: identifier}) do
-    identifier in [:else, :rescue, :catch]
-  end
-
-  defp clause_block_identifier?(_meta), do: false
-
   # Changes placeholder to real expression
 
   defp insert_quoted({:__EEX__, _, [key]}, quoted) do
-    Map.fetch!(quoted, key)
+    {^key, value} = List.keyfind quoted, key, 0
+    value
   end
 
   defp insert_quoted({left, line, right}, quoted) do
@@ -520,63 +107,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(~c"<%") == 2
-    column + 2 + length(mark)
-  end
-
-  defp syntax_error!(message, meta, state) do
-    raise EEx.SyntaxError,
-      message: message,
-      snippet: code_snippet(state.source, state.indentation, meta),
-      file: state.file,
-      line: meta.line,
-      column: meta.column
-  end
-
-  defp handle_expr(buffer, mark, expr, meta, state) do
-    state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)
-  rescue
-    e in EEx.SyntaxError ->
-      reraise %{
-                e
-                | file: e.file || state.file,
-                  line: e.line || meta.line,
-                  column: e.column || meta.column,
-                  snippet: e.snippet || code_snippet(state.source, state.indentation, meta)
-              },
-              __STACKTRACE__
-  end
-
-  defp code_snippet(source, indentation, meta) do
-    line_start = max(meta.line - 3, 1)
-    line_end = meta.line
-    digits = line_end |> Integer.to_string() |> byte_size()
-    number_padding = String.duplicate(" ", digits)
-    indentation = String.duplicate(" ", indentation)
-
-    source
-    |> String.split(["\r\n", "\n"])
-    |> Enum.slice((line_start - 1)..(line_end - 1))
-    |> Enum.map_reduce(line_start, fn
-      expr, line_number when line_number == line_end ->
-        arrow = String.duplicate(" ", meta.column - 1) <> "^"
-        {"#{line_number} | #{indentation}#{expr}\n #{number_padding}| #{arrow}", line_number + 1}
-
-      expr, line_number ->
-        line_number_padding = String.pad_leading("#{line_number}", digits)
-        {"#{line_number_padding} | #{indentation}#{expr}", line_number + 1}
-    end)
-    |> case do
-      {[], _} -> ""
-      {snippet, _} -> Enum.join(["\n #{number_padding}|" | snippet], "\n")
-    end
-  end
 end

lib/eex/lib/eex/engine.ex

@@ -1,229 +1,116 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 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 three functions:
 
-  This module also ships with a default engine implementation
-  you can delegate to. See `EEx.SmartEngine` as an example.
+    * `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
+  use Behaviour
 
-  @doc """
-  Called at the beginning of every template.
-
-  It receives the options during compilation, including the
-  ones managed by EEx, such as `:line` and `:file`, as well
-  as custom engine options.
-
-  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()
+  defcallback handle_body(Macro.t) :: Macro.t
+  defcallback handle_text(Macro.t, binary) :: Macro.t
+  defcallback handle_expr(Macro.t, binary, Macro.t) :: Macro.t
 
   @doc false
-  @deprecated "Use explicit delegation to EEx.Engine instead"
   defmacro __using__(_) do
     quote do
       @behaviour EEx.Engine
 
-      def init(opts) do
-        EEx.Engine.init(opts)
+      def handle_body(body) do
+        EEx.Engine.handle_body(body)
       end
 
-      def handle_body(state) do
-        EEx.Engine.handle_body(state)
+      def handle_text(buffer, text) do
+        EEx.Engine.handle_text(buffer, text)
       end
 
-      def handle_begin(state) do
-        EEx.Engine.handle_begin(state)
+      def handle_expr(buffer, mark, expr) do
+        EEx.Engine.handle_expr(buffer, mark, expr)
       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)
-      end
-
-      defoverridable EEx.Engine
+      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2]
     end
   end
 
   @doc """
   Handles assigns in quoted expressions.
 
-  A warning will be printed on missing assigns.
-  Future versions will raise.
-
   This can be added to any custom engine by invoking
-  `handle_assign/1` with `Macro.prewalk/2`:
+  `handle_assign/3` with `Macro.prewalk/1`:
 
-      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()
   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: Dict.get(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
-  def fetch_assign!(assigns, key) do
-    case Access.fetch(assigns, key) do
-      {:ok, val} ->
-        val
+  @doc """
+  The default implementation implementation simply returns the
+  given expression.
+  """
+  def handle_body(quoted) do
+    quoted
+  end
 
-      :error ->
-        keys = Enum.map(assigns, &elem(&1, 0))
+  @doc """
+  The default implementation simply concatenates text to the buffer.
+  """
+  def handle_text(buffer, text) do
+    quote do: unquote(buffer) <> unquote(text)
+  end
 
-        IO.warn(
-          "assign @#{key} not available in EEx template. " <>
-            "Please ensure all assigns are given as options. " <>
-            "Available assigns: #{inspect(keys)}"
-        )
+  @doc """
+  Implements expressions according to the markers.
 
-        nil
+      <% 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
+      tmp = unquote(buffer)
+      tmp <> (case unquote(expr) do
+        bin when is_binary(bin) -> bin
+        oth -> String.Chars.to_string(oth)
+      end)
     end
   end
 
-  @doc "Default implementation for `c:init/1`."
-  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: []}
-  end
-
-  @doc "Default implementation for `c:handle_end/1`."
-  def handle_end(quoted) do
-    handle_body(quoted)
-  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)}
-  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(String.to_unsafe_atom("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
+      tmp = unquote(buffer)
+      unquote(expr)
+      tmp
+    end
   end
 end

lib/eex/lib/eex/smart_engine.ex

@@ -1,7 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule EEx.SmartEngine do
   @moduledoc """
   The default engine used by EEx.
@@ -15,9 +11,9 @@ defmodule EEx.SmartEngine do
       "1"
 
   In the example above, we can access the value `foo` under
-  the binding `assigns` using `@foo`. This is useful because
-  a template, after being compiled, can receive different
-  assigns and would not require recompilation for each
+  the binding `assigns` using `@foo`. This is useful when
+  a template, after compiled, may receive different assigns
+  and the developer don't want to recompile it for each
   variable set.
 
   Assigns can also be used when compiled to a function:
@@ -28,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,161 @@
+defmodule EEx.Tokenizer do
+  @moduledoc false
+
+  @doc """
+  Tokenizes the given char list or binary.
+  It returns 4 different types of tokens as result:
+
+    * `{:text, contents}`
+    * `{:expr, line, marker, contents}`
+    * `{:start_expr, line, marker, contents}`
+    * `{:middle_expr, line, marker, contents}`
+    * `{:end_expr, line, marker, contents}`
+
+  """
+  def tokenize(bin, line) when is_binary(bin) do
+    tokenize(String.to_char_list(bin), line)
+  end
+
+  def tokenize(list, line) do
+    Enum.reverse(tokenize(list, line, [], []))
+  end
+
+  defp tokenize('<%%' ++ t, line, buffer, acc) do
+    {buffer, new_line, rest} = tokenize_expr t, line, [?%, ?<|buffer]
+    tokenize rest, new_line, [?>, ?%|buffer], acc
+  end
+
+  defp tokenize('<%#' ++ t, line, buffer, acc) do
+    {_, new_line, rest} = tokenize_expr t, line, []
+    tokenize rest, new_line, buffer, acc
+  end
+
+  defp tokenize('<%' ++ t, line, buffer, acc) do
+    {marker, t} = retrieve_marker(t)
+    {expr, new_line, rest} = tokenize_expr t, line, []
+
+    token = token_name(expr)
+    acc   = tokenize_text(buffer, acc)
+    final = {token, line, marker, Enum.reverse(expr)}
+    tokenize rest, new_line, [], [final | acc]
+  end
+
+  defp tokenize('\n' ++ t, line, buffer, acc) do
+    tokenize t, line + 1, [?\n|buffer], acc
+  end
+
+  defp tokenize([h|t], line, buffer, acc) do
+    tokenize t, line, [h|buffer], acc
+  end
+
+  defp tokenize([], _line, buffer, acc) do
+    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 tokenize_expr([?%, ?>|t], line, buffer) do
+    {buffer, line, t}
+  end
+
+  defp tokenize_expr('\n' ++ t, line, buffer) do
+    tokenize_expr t, line + 1, [?\n|buffer]
+  end
+
+  defp tokenize_expr([h|t], line, buffer) do
+    tokenize_expr t, line, [h|buffer]
+  end
+
+  defp tokenize_expr([], _line, _buffer) do
+    raise EEx.SyntaxError, message: "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
+
+  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, 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
+end

lib/eex/mix.exs

@@ -1,15 +1,9 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-defmodule EEx.MixProject do
+defmodule EEx.Mixfile do
   use Mix.Project
 
   def project do
-    [
-      app: :eex,
-      version: System.version(),
-      build_per_environment: false
-    ]
+    [app: :eex,
+     version: System.version,
+     build_per_environment: false]
   end
 end

lib/eex/test/eex/smart_engine_test.exs

@@ -1,54 +1,36 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.SmartEngineTest do
   use ExUnit.Case, async: true
 
   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})
-  end
-
-  test "error with missing assigns" do
-    stderr =
-      ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        assert_eval("", "<%= @foo %>", assigns: %{})
-      end)
-
-    assert stderr =~ "assign @foo not available in EEx template"
+    assert_eval "1", "<%= @foo %>", assigns: %{foo: 1}
   end
 
   test "evaluates with loops" do
-    assert_eval("1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>")
+    assert_eval "1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>"
   end
 
-  test "preserves line numbers in assignments" do
-    result = EEx.compile_string("foo\n<%= @hello %>", engine: EEx.SmartEngine)
-
+  test "compiled preserved line numbers" do
+    result = EEx.compile_string("<%= @hello %>", engine: EEx.SmartEngine)
     Macro.prewalk(result, fn
-      {_left, meta, [_, :hello]} ->
-        assert Keyword.get(meta, :line) == 2
-        send(self(), :found)
-
-      node ->
-        node
+      {_left, meta, _right} ->
+        assert Keyword.get(meta, :line, 0) in [0, 1]
+      _ ->
+        :ok
     end)
-
-    assert_received :found
   end
 
   defp assert_eval(expected, actual, binding \\ []) do
-    result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.SmartEngine)
+    result = EEx.eval_string(actual, binding, file: __ENV__.file)
     assert result == expected
   end
 end

lib/eex/test/eex/tokenizer_test.exs

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

lib/eex/test/fixtures/eex_template_with_syntax_error.eex

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

lib/eex/test/test_helper.exs

@@ -1,20 +1 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-{line_exclude, line_include} =
-  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
-
-Code.require_file("../../elixir/scripts/cover_record.exs", __DIR__)
-CoverageRecorder.maybe_record("eex")
-
-maybe_seed_opt = if seed = System.get_env("SEED"), do: [seed: String.to_integer(seed)], else: []
-
-ex_unit_opts =
-  [
-    trace: !!System.get_env("TRACE"),
-    include: line_include,
-    exclude: line_exclude
-  ] ++ maybe_seed_opt
-
-ExUnit.start(ex_unit_opts)
+ExUnit.start [trace: "--trace" in System.argv]

lib/elixir/Emakefile

@@ -1,20 +0,0 @@
-%% SPDX-License-Identifier: Apache-2.0
-%% SPDX-FileCopyrightText: 2021 The Elixir Team
-%% SPDX-FileCopyrightText: 2012 Plataformatec
-
-{'src/*', [
-  warn_unused_vars,
-  warn_export_all,
-  warn_shadow_vars,
-  warn_unused_import,
-  warn_unused_function,
-  warn_bif_clash,
-  warn_unused_record,
-  warn_deprecated_function,
-  warn_obsolete_guard,
-  warn_exported_vars,
-  %% Enable this when we require Erlang/OTP 27+
-  %% warnings_as_errors,
-  debug_info,
-  {outdir, "ebin/"}
-]}.

lib/elixir/lib/agent.ex

@@ -1,7 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule Agent do
   @moduledoc """
   Agents are a simple abstraction around state.
@@ -10,61 +6,41 @@ defmodule Agent do
   must be accessed from different processes or by the same process
   at different points in time.
 
-  The `Agent` module provides a basic server implementation that
+  The Agent module provides a basic server implementation that
   allows state to be retrieved and updated via a simple API.
 
   ## Examples
 
-  For example, the following agent implements a counter:
+  For example, in the Mix tool that ships with Elixir, we need
+  to keep a set of all tasks executed by a given project. Since
+  this set is shared, we can implement it with an Agent:
 
-      defmodule Counter do
-        use Agent
-
-        def start_link(initial_value) do
-          Agent.start_link(fn -> initial_value end, name: __MODULE__)
+      defmodule Mix.TasksServer do
+        def start_link do
+          Agent.start_link(fn -> HashSet.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__, &Set.put(&1, item))
         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.
-
-  > #### `use Agent` {: .info}
-  >
-  > When you `use Agent`, the `Agent` module will define a
-  > `child_spec/1` function, so your module can be used
-  > as a child in a supervision tree.
-
-  Agents provide a segregation between the client and server APIs (similar to
-  `GenServer`s). In particular, the functions passed as arguments to the calls to
-  `Agent` functions are invoked inside the agent (the server). This distinction
-  is important because you may want to avoid expensive operations inside the
-  agent, as they will effectively block the agent until the request is
-  fulfilled.
+  Note that agents still provide a segregation between the
+  client and server APIs, as seen in GenServers. In particular,
+  all code inside the function passed to the agent is executed
+  by the agent. This distinction is important because you may
+  want to avoid expensive operations inside the agent, as it will
+  effectively block the agent until the request is fulfilled.
 
   Consider these two examples:
 
@@ -75,85 +51,25 @@ defmodule Agent do
 
       # Compute in the agent/client
       def get_something(agent) do
-        Agent.get(agent, & &1) |> do_something_expensive()
+        Agent.get(agent, &(&1)) |> do_something_expensive()
       end
 
-  The first function blocks the agent. The second function copies all the state
-  to the client and then executes the operation in the client. One aspect to
-  consider is whether the data is large enough to require processing in the server,
-  at least initially, or small enough to be sent to the client cheaply. Another
-  factor is whether the data needs to be processed atomically: getting the
-  state and calling `do_something_expensive(state)` outside of the agent means
-  that the agent's state can be updated in the meantime. This is specially
-  important in case of updates as computing the new state in the client rather
-  than in the server can lead to race conditions if multiple clients are trying
-  to update the same state to different values.
+  The first one blocks the agent while the second one copies
+  all the state to the client and executes the operation in the client.
+  The trade-off here is exactly if the data is small enough to be
+  sent to the client cheaply or large enough to require processing on
+  the server (or at least some initial processing).
 
-  ## How to supervise
+  ## Name Registration
 
-  An `Agent` is most commonly started under a supervision tree.
-  When we invoke `use Agent`, it automatically defines a `child_spec/1`
-  function that allows us to start the agent directly under a supervisor.
-  To start an agent under a supervisor with an initial counter of 0,
-  one may do:
-
-      children = [
-        {Counter, 0}
-      ]
-
-      Supervisor.start_link(children, strategy: :one_for_all)
-
-  While one could also simply pass the `Counter` as a child to the supervisor,
-  such as:
-
-      children = [
-        Counter # Same as {Counter, []}
-      ]
-
-      Supervisor.start_link(children, strategy: :one_for_all)
-
-  The definition above wouldn't work for this particular example,
-  as it would attempt to start the counter with an initial value
-  of an empty list. However, this may be a viable option in your
-  own agents. A common approach is to use a keyword list, as that
-  would allow setting the initial value and giving a name to the
-  counter process, for example:
-
-      def start_link(opts) do
-        {initial_value, opts} = Keyword.pop(opts, :initial_value, 0)
-        Agent.start_link(fn -> initial_value end, opts)
-      end
-
-  and then you can use `Counter`, `{Counter, name: :my_counter}` or
-  even `{Counter, initial_value: 0, name: :my_counter}` as a child
-  specification.
-
-  `use Agent` also accepts a list of options which configures the
-  child specification and therefore how it runs under a supervisor.
-  The generated `child_spec/1` can be customized with the following options:
-
-    * `:id` - the child specification identifier, defaults to the current module
-    * `:restart` - when the child should be restarted, defaults to `:permanent`
-    * `:shutdown` - how to shut down the child, either immediately or by giving it time to shut down
-
-  For example:
-
-      use Agent, restart: :transient, shutdown: 10_000
-
-  See the "Child specification" section in the `Supervisor` module for more
-  detailed information. The `@doc` annotation immediately preceding
-  `use Agent` will be attached to the generated `child_spec/1` function.
-
-  ## Name registration
-
-  An agent is bound to the same name registration rules as GenServers.
-  Read more about it in the `GenServer` documentation.
+  An Agent is bound to the same name registration rules as GenServers.
+  Read more about it in the `GenServer` docs.
 
   ## A word on distributed agents
 
   It is important to consider the limitations of distributed agents. Agents
-  provide two APIs, one that works with anonymous functions and another
-  that expects an explicit module, function, and arguments.
+  provides two APIs, one that works with anonymous functions and another
+  that expects explicit module, function and arguments.
 
   In a distributed setup with multiple nodes, the API that accepts anonymous
   functions only works if the caller (client) and the agent have the same
@@ -166,21 +82,20 @@ defmodule Agent do
   In this setup, part of your environment will have one version of a given
   module and the other part another version (the newer one) of the same module.
 
-  The best solution is to simply use the explicit module, function, and arguments
+  The best solution is to simply use the explicit module, function and arguments
   APIs when working with distributed agents.
 
   ## Hot code swapping
 
   An agent can have its code hot swapped live by simply passing a module,
-  function, and arguments tuple to the update instruction. For example, imagine
+  function and args tuple to the update instruction. For example, imagine
   you have an agent named `:sample` and you want to convert its inner state
-  from a keyword list to a map. It can be done with the following
+  from some dict structure to a map. It can be done with the following
   instruction:
 
       {:update, :sample, {:advanced, {Enum, :into, [%{}]}}}
 
-  The agent's state will be added to the given list of arguments (`[%{}]`) as
-  the first argument.
+  The agent's state will be added to the given list as the first argument.
   """
 
   @typedoc "Return values of `start*` functions"
@@ -195,51 +110,14 @@ defmodule Agent do
   @typedoc "The agent state"
   @type state :: term
 
-  @doc """
-  Returns a specification to start an agent under a supervisor.
-
-  See the "Child specification" section in the `Supervisor` module for more detailed information.
-  """
-  @doc since: "1.5.0"
-  def child_spec(arg) do
-    %{
-      id: Agent,
-      start: {Agent, :start_link, [arg]}
-    }
-  end
-
-  @doc false
-  defmacro __using__(opts) do
-    quote location: :keep, bind_quoted: [opts: opts] do
-      if not Module.has_attribute?(__MODULE__, :doc) do
-        @doc """
-        Returns a specification to start this module under a supervisor.
-
-        See `Supervisor`.
-        """
-      end
-
-      def child_spec(arg) do
-        default = %{
-          id: __MODULE__,
-          start: {__MODULE__, :start_link, [arg]}
-        }
-
-        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
-      end
-
-      defoverridable child_spec: 1
-    end
-  end
-
   @doc """
   Starts an agent linked to the current process with the given function.
 
   This is often used to start the agent as part of a supervision tree.
 
-  Once the agent is spawned, the given function `fun` is invoked in the server
-  process, and should return the initial agent state. Note that `start_link/2`
-  does not return until the given function has returned.
+  Once the agent is spawned, the given function is invoked and its return
+  value is used as the agent state. Note that `start_link` does not return
+  until the given function has returned.
 
   ## Options
 
@@ -251,7 +129,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`.
@@ -259,36 +137,26 @@ defmodule Agent do
   ## Return values
 
   If the server is successfully created and initialized, the function returns
-  `{:ok, pid}`, where `pid` is the PID of the server. If an agent with the
-  specified name already exists, the function returns
-  `{:error, {:already_started, pid}}` with the PID of that process.
-
-  If the given function callback fails, the function returns `{:error, reason}`.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
-      iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise "oops" end)
-      iex> exception
-      %RuntimeError{message: "oops"}
+  `{:ok, pid}`, where `pid` is the pid of the server. If there already exists
+  an agent with the specified name, the function returns
+  `{:error, {:already_started, pid}}` with the pid of that process.
 
+  If the given function callback fails with `reason`, the function returns
+  `{:error, reason}`.
   """
-  @spec start_link((-> term), GenServer.options()) :: on_start
+  @spec start_link((() -> term), GenServer.options) :: on_start
   def start_link(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start_link(Agent.Server, fun, options)
   end
 
   @doc """
-  Starts an agent linked to the current process.
+  Starts an agent linked to the current process with the given module
+  function and arguments.
 
-  Same as `start_link/2` but a module, function, and arguments are expected
-  instead of an anonymous function; `fun` in `module` will be called with the
-  given arguments `args` to initialize the state.
+  Same as `start_link/2` but a module, function and args are expected
+  instead of an anonymous function.
   """
-  @spec start_link(module, atom, [term], 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
@@ -297,48 +165,31 @@ defmodule Agent do
   Starts an agent process without links (outside of a supervision tree).
 
   See `start_link/2` for more information.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
   """
-  @spec start((-> term), GenServer.options()) :: on_start
+  @spec start((() -> term), GenServer.options) :: on_start
   def start(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start(Agent.Server, fun, options)
   end
 
   @doc """
-  Starts an agent without links with the given module, function, and arguments.
+  Starts an agent with the given module function and arguments.
 
-  See `start_link/4` for more information.
+  Similar to `start/2` but a module, function and args are expected
+  instead of an anonymous function.
   """
-  @spec start(module, atom, [term], GenServer.options()) :: on_start
+  @spec start(module, atom, [any], GenServer.options) :: on_start
   def start(module, fun, args, options \\ []) do
     GenServer.start(Agent.Server, {module, fun, args}, options)
   end
 
   @doc """
-  Gets an agent value via the given anonymous function.
+  Gets an agent value via the given function.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The result of the function invocation is
-  returned from this function.
-
-  `timeout` is a non-negative integer which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
+  returned.
 
+  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get(agent, (state -> a), timeout) :: a when a: var
   def get(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -348,38 +199,24 @@ defmodule Agent do
   @doc """
   Gets an agent value via the given function.
 
-  Same as `get/3` but a module, function, and arguments are expected
+  Same as `get/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
-  @spec get(agent, module, atom, [term], timeout) :: term
+  @spec get(agent, module, atom, [term], timeout) :: any
   def get(agent, module, fun, args, timeout \\ 5000) do
     GenServer.call(agent, {:get, {module, fun, args}}, timeout)
   end
 
   @doc """
-  Gets and updates the agent state in one operation via the given anonymous
-  function.
+  Gets and updates the agent state in one operation.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The function must return a tuple with two
-  elements, the first being the value to return (that is, the "get" value)
-  and the second one being the new state of the agent.
-
-  `timeout` is a non-negative integer which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)
-      42
-      iex> Agent.get(pid, fn state -> state end)
-      43
+  elements, the first being the value to return (i.e. the `get` value)
+  and the second one is the new state.
 
+  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get_and_update(agent, (state -> {a, state}), timeout) :: a when a: var
   def get_and_update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -387,40 +224,25 @@ defmodule Agent do
   end
 
   @doc """
-  Gets and updates the agent state in one operation via the given function.
+  Gets and updates the agent state in one operation.
 
-  Same as `get_and_update/3` but a module, function, and arguments are expected
+  Same as `get_and_update/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
-  @spec get_and_update(agent, module, atom, [term], timeout) :: term
+  @spec get_and_update(agent, module, atom, [term], timeout) :: any
   def get_and_update(agent, module, fun, args, timeout \\ 5000) do
     GenServer.call(agent, {:get_and_update, {module, fun, args}}, timeout)
   end
 
   @doc """
-  Updates the agent state via the given anonymous function.
+  Updates the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
+  passing the agent state. The function must return the new state.
 
+  A timeout can also be specified (it has a default value of 5000).
   This function always returns `:ok`.
-
-  `timeout` is a non-negative integer which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.update(pid, fn state -> state + 1 end)
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      43
-
   """
   @spec update(agent, (state -> state), timeout) :: :ok
   def update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -428,20 +250,11 @@ defmodule Agent do
   end
 
   @doc """
-  Updates the agent state via the given function.
+  Updates the agent state.
 
-  Same as `update/3` but a module, function, and arguments are expected
+  Same as `update/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.update(pid, Kernel, :+, [12])
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      54
-
+  argument to the given list of args.
   """
   @spec update(agent, module, atom, [term], timeout) :: :ok
   def update(agent, module, fun, args, timeout \\ 5000) do
@@ -449,23 +262,13 @@ defmodule Agent do
   end
 
   @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
+  Performs a cast (fire and forget) operation on the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
-
-  Note that `cast` returns `:ok` immediately, regardless of whether `agent` (or
-  the node it should live on) exists.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.cast(pid, fn state -> state + 1 end)
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      43
+  passing the agent state. The function must return the new state.
 
+  Note that `cast` returns `:ok` immediately, regardless of whether the
+  destination node or agent exists.
   """
   @spec cast(agent, (state -> state)) :: :ok
   def cast(agent, fun) when is_function(fun, 1) do
@@ -473,20 +276,11 @@ defmodule Agent do
   end
 
   @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
+  Performs a cast (fire and forget) operation on the agent state.
 
-  Same as `cast/2` but a module, function, and arguments are expected
+  Same as `cast/2` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.cast(pid, Kernel, :+, [12])
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      54
-
+  argument to the given list of args.
   """
   @spec cast(agent, module, atom, [term]) :: :ok
   def cast(agent, module, fun, args) do
@@ -494,25 +288,12 @@ defmodule Agent do
   end
 
   @doc """
-  Synchronously stops the agent with the given `reason`.
-
-  It returns `:ok` if the agent terminates with the given
-  reason. If the agent terminates with another reason, the call will
-  exit.
-
-  This function keeps OTP semantics regarding error reporting.
-  If the reason is any other than `:normal`, `:shutdown` or
-  `{:shutdown, _}`, an error report will be logged.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.stop(pid)
-      :ok
+  Stops the agent.
 
+  Returns `:ok` if the agent is stopped within the given `timeout`.
   """
-  @spec stop(agent, reason :: term, timeout) :: :ok
-  def stop(agent, reason \\ :normal, timeout \\ :infinity) do
-    GenServer.stop(agent, reason, timeout)
+  @spec stop(agent, timeout) :: :ok
+  def stop(agent, timeout \\ 5000) do
+    GenServer.call(agent, :stop, timeout)
   end
 end

lib/elixir/lib/agent/server.ex

@@ -1,14 +1,9 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule Agent.Server do
   @moduledoc false
 
   use GenServer
 
   def init(fun) do
-    _ = initial_call(fun)
     {:ok, run(fun, [])}
   end
 
@@ -17,39 +12,45 @@ defmodule Agent.Server do
   end
 
   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}
-    end
+    {reply, state} = run(fun, [state])
+    {:reply, reply, state}
   end
 
   def handle_call({:update, fun}, _from, state) do
     {:reply, :ok, run(fun, [state])}
   end
 
+  def handle_call(:stop, _from, state) do
+    {:stop, :normal, :ok, 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
 
-  defp initial_call(mfa) do
-    _ = Process.put(:"$initial_call", get_initial_call(mfa))
+  def terminate(_reason, _state) do
+    # There is a race condition if the agent is
+    # restarted too fast and it is registered.
+    try do
+      self |> :erlang.process_info(:registered_name) |> elem(1) |> Process.unregister
+    rescue
+      _ -> :ok
+    end
     :ok
   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, name, 0}
-  end
-
-  defp get_initial_call({mod, fun, args}) do
-    {mod, fun, length(args)}
-  end
-
   defp run({m, f, a}, extra), do: apply(m, f, extra ++ a)
   defp run(fun, extra), do: apply(fun, extra)
 end

lib/elixir/lib/atom.ex

@@ -1,86 +1,25 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 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"
-
+  @doc """
+  Convenience functions for working with atoms.
   """
 
   @doc """
-  Converts an atom to a string.
+  Converts an atom to string.
 
   Inlined by the compiler.
-
-  ## Examples
-
-      iex> Atom.to_string(:foo)
-      "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 """
-  Converts an atom to a charlist.
+  Converts an atom to a char list.
 
   Inlined by the compiler.
-
-  ## Examples
-
-      iex> Atom.to_charlist(:"An atom")
-      ~c"An atom"
-
   """
-  @spec to_charlist(atom) :: charlist
-  def to_charlist(atom) do
+  @spec to_char_list(atom) :: char_list
+  def to_char_list(atom) do
     :erlang.atom_to_list(atom)
   end
-
-  @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,41 +1,63 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule Behaviour do
   @moduledoc """
-  Mechanism for handling behaviours.
+  Utilities for defining behaviour interfaces.
 
-  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.
+  Behaviours can be referenced by other modules
+  to ensure they implement required callbacks.
 
-  Instead of `MyModule.__behaviour__(:callbacks)`,
-  `MyModule.behaviour_info(:callbacks)` can be used. `behaviour_info/1`
-  is documented in `Module`.
+  For example, you can specify the `URI.Parser`
+  behaviour as follows:
+
+      defmodule URI.Parser do
+        use Behaviour
+
+        @doc "Parses the given URL"
+        defcallback parse(uri_info :: URI.t) :: URI.t
+
+        @doc "Defines a default port"
+        defcallback default_port() :: integer
+      end
+
+  And then a module may use it as:
+
+      defmodule URI.HTTP do
+        @behaviour URI.Parser
+        def default_port(), do: 80
+        def parse(info), do: info
+      end
+
+  If the behaviour changes or `URI.HTTP` does
+  not implement one of the callbacks, a warning
+  will be raised.
+
+  ## Implementation
+
+  Since Erlang R15, behaviours must be defined via
+  `@callback` attributes. `defcallback` is a simple
+  mechanism that defines the `@callback` attribute
+  according to the given type specification. `defcallback` allows
+  documentation to be created for the callback and defines
+  a custom function signature.
+
+  The callbacks and their documentation can be retrieved
+  via the `__behaviour__` callback function.
   """
 
-  @moduledoc deprecated: "Use @callback and @macrocallback attributes instead"
-
   @doc """
-  Defines a function callback according to the given type specification.
+  Define 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)))
+    do_defcallback(split_spec(spec, quote(do: term)), __CALLER__)
   end
 
   @doc """
-  Defines a macro callback according to the given type specification.
+  Define 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_defmacrocallback(split_spec(spec, quote(do: Macro.t)), __CALLER__)
   end
 
-  defp split_spec({:when, _, [{:"::", _, [spec, return]}, guard]}, _default) do
+  defp split_spec({:when, _, [{:::, _, [spec, return]}, guard]}, _default) do
     {spec, return, guard}
   end
 
@@ -43,7 +65,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
 
@@ -51,38 +73,40 @@ defmodule Behaviour do
     {spec, default, []}
   end
 
-  defp do_defcallback(kind, {spec, return, guards}) do
+  defp do_defcallback({spec, return, guards}, caller) do
     case Macro.decompose_call(spec) do
       {name, args} ->
-        do_callback(kind, name, args, return, guards)
-
+        do_callback(:def, name, args, name, length(args), args, return, guards, caller)
       _ ->
-        raise ArgumentError, "invalid syntax in #{kind}callback #{Macro.to_string(spec)}"
+        raise ArgumentError, "invalid syntax in defcallback #{Macro.to_string(spec)}"
     end
   end
 
-  defp do_callback(kind, name, args, return, guards) do
-    fun = fn
-      {:"::", _, [left, right]} ->
+  defp do_defmacrocallback({spec, return, guards}, caller) do
+    case Macro.decompose_call(spec) do
+      {name, args} ->
+        do_callback(:defmacro, :"MACRO-#{name}", [quote(do: env :: Macro.Env.t)|args],
+                    name, length(args), args, return, guards, caller)
+      _ ->
+        raise ArgumentError, "invalid syntax in defmacrocallback #{Macro.to_string(spec)}"
+    end
+  end
+
+  defp do_callback(kind, name, args, docs_name, docs_arity, _docs_args, return, guards, caller) do
+    Enum.each args, fn
+      {:::, _, [left, right]} ->
         ensure_not_default(left)
         ensure_not_default(right)
         left
-
       other ->
         ensure_not_default(other)
         other
     end
 
-    :lists.foreach(fun, args)
-
-    spec =
-      quote do
-        unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
-      end
-
-    case kind do
-      :def -> quote(do: @callback(unquote(spec)))
-      :defmacro -> quote(do: @macrocallback(unquote(spec)))
+    quote do
+      @callback unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
+      Behaviour.store_docs(__MODULE__, unquote(caller.line), unquote(kind),
+                           unquote(docs_name), unquote(docs_arity))
     end
   end
 
@@ -92,37 +116,37 @@ defmodule Behaviour do
 
   defp ensure_not_default(_), do: :ok
 
+  @doc false
+  def store_docs(module, line, kind, name, arity) do
+    doc = Module.get_attribute module, :doc
+    Module.delete_attribute module, :doc
+    Module.put_attribute module, :behaviour_docs, {{name, arity}, line, kind, doc}
+  end
+
   @doc false
   defmacro __using__(_) 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"
+      Module.register_attribute(__MODULE__, :behaviour_docs, accumulate: true)
+      @before_compile unquote(__MODULE__)
+      import unquote(__MODULE__)
+    end
+  end
 
-      IO.warn(warning)
+  @doc false
+  defmacro __before_compile__(env) do
+    docs = if Code.compiler_options[:docs] do
+      Enum.reverse Module.get_attribute(env.module, :behaviour_docs)
+    end
 
+    quote do
       @doc false
       def __behaviour__(:callbacks) do
         __MODULE__.behaviour_info(:callbacks)
       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
-          case kind do
-            :callback -> {{name, arity}, line, :def, __behaviour__doc_value(doc)}
-            :macrocallback -> {{name, arity}, line, :defmacro, __behaviour__doc_value(doc)}
-          end
-        end
+        unquote(Macro.escape(docs))
       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
 end

lib/elixir/lib/bitwise.ex

@@ -1,44 +1,41 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule Bitwise do
   @moduledoc """
-  A set of functions that perform calculations on bits.
+  This module provides macros and operators for bitwise operators.
+  These macros can be used in guards.
 
-  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 easiest way to use is to simply import them into
+  your module:
 
-  ## Guards
+      iex> use Bitwise
+      iex> bnot 1
+      -2
+      iex> 1 &&& 1
+      1
 
-  All bitwise functions can be used in guards:
+  You can select to include only or skip operators by passing options:
 
-      iex> odd? = fn
-      ...>   int when Bitwise.band(int, 1) == 1 -> true
-      ...>   _ -> false
-      ...> end
-      iex> odd?.(1)
-      true
+      iex> use Bitwise, only_operators: true
+      iex> 1 &&& 1
+      1
 
-  All functions in this module are inlined by the compiler.
   """
 
-  @doc false
-  @deprecated "import Bitwise instead"
+  @doc """
+  Allow a developer to use this module in their programs with
+  the following options:
+
+    * `:only_operators` - include only operators
+    * `:skip_operators` - skip operators
+
+  """
   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)
@@ -46,229 +43,86 @@ defmodule Bitwise do
   end
 
   @doc """
-  Calculates the bitwise NOT of the argument.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
-      iex> bnot(2)
-      -3
-
-      iex> bnot(2) &&& 3
-      1
-
+  Bitwise not.
   """
-  @doc guard: true
-  @spec bnot(integer) :: integer
-  def bnot(expr) do
-    :erlang.bnot(expr)
-  end
-
-  @doc false
-  def unquote(:"~~~")(expr) do
-    :erlang.bnot(expr)
+  defmacro bnot(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
-
+  Bitwise not as operator.
   """
-  @doc guard: true
-  @spec band(integer, integer) :: integer
-  def band(left, right) do
-    :erlang.band(left, right)
+  defmacro ~~~expr do
+    quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
-  Bitwise AND operator.
-
-  Calculates the bitwise AND of its arguments.
-
-  Allowed in guard tests. Inlined by the compiler.
-
-  ## Examples
-
-      iex> 9 &&& 3
-      1
-
+  Bitwise and.
   """
-  @doc guard: true
-  @spec integer &&& integer :: integer
-  def left &&& right do
-    :erlang.band(left, right)
+  defmacro band(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
-
+  Bitwise and as operator.
   """
-  @doc guard: true
-  @spec bor(integer, integer) :: integer
-  def bor(left, right) do
-    :erlang.bor(left, right)
+  defmacro left &&& right do
+    quote do: :erlang.band(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
-
-      iex> 9 ||| 3
-      11
-
+  Bitwise or.
   """
-  @doc guard: true
-  @spec integer ||| integer :: integer
-  def left ||| right do
-    :erlang.bor(left, right)
+  defmacro bor(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
-
+  Bitwise or as operator.
   """
-  @doc guard: true
-  @spec bxor(integer, integer) :: integer
-  def bxor(left, right) do
-    :erlang.bxor(left, right)
-  end
-
-  @doc false
-  def unquote(:"^^^")(left, right) do
-    :erlang.bxor(left, right)
+  defmacro left ||| right do
+    quote do: :erlang.bor(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
-
+  Bitwise xor.
   """
-  @doc guard: true
-  @spec bsl(integer, integer) :: integer
-  def bsl(left, right) do
-    :erlang.bsl(left, right)
+  defmacro bxor(left, right) do
+    quote do: :erlang.bxor(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
-
-      iex> 1 <<< 2
-      4
-
-      iex> 1 <<< -2
-      0
-
-      iex> -1 <<< 2
-      -4
-
-      iex> -1 <<< -2
-      -1
-
+  Bitwise xor as operator.
   """
-  @doc guard: true
-  @spec integer <<< integer :: integer
-  def left <<< right do
-    :erlang.bsl(left, right)
+  defmacro left ^^^ right do
+    quote do: :erlang.bxor(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
-
+  Arithmetic bitshift left.
   """
-  @doc guard: true
-  @spec bsr(integer, integer) :: integer
-  def bsr(left, right) do
-    :erlang.bsr(left, right)
+  defmacro bsl(left, right) do
+    quote do: :erlang.bsl(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
-
-      iex> 1 >>> 2
-      0
-
-      iex> 1 >>> -2
-      4
-
-      iex> -1 >>> 2
-      -1
-
-      iex> -1 >>> -2
-      -4
-
+  Arithmetic bitshift left as operator.
   """
-  @doc guard: true
-  @spec integer >>> integer :: integer
-  def left >>> right do
-    :erlang.bsr(left, right)
+  defmacro left <<< right do
+    quote do: :erlang.bsl(unquote(left), unquote(right))
+  end
+
+  @doc """
+  Arithmetic bitshift right.
+  """
+  defmacro bsr(left, right) do
+    quote do: :erlang.bsr(unquote(left), unquote(right))
+  end
+
+  @doc """
+  Arithmetic bitshift right as operator.
+  """
+  defmacro left >>> right do
+    quote do: :erlang.bsr(unquote(left), unquote(right))
   end
 end

lib/elixir/lib/calendar/date_range.ex

@@ -1,215 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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.
-
-  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
-        }
-
-  @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]
-
-  defimpl Enumerable do
-    def member?(
-          %Date.Range{
-            first: %{calendar: calendar},
-            first_in_iso_days: first_days,
-            last_in_iso_days: last_days,
-            step: step
-          },
-          %Date{calendar: calendar} = date
-        ) do
-      {days, _} = Date.to_iso_days(date)
-
-      in_range? =
-        if step > 0 do
-          first_days <= days and days <= last_days and rem(days - first_days, step) == 0
-        else
-          last_days <= days and days <= first_days and rem(days - first_days, step) == 0
-        end
-
-      {:ok, in_range?}
-    end
-
-    def member?(%Date.Range{step: _}, _) do
-      {:ok, false}
-    end
-
-    # TODO: Remove me on v2.0
-    member? =
-      quote generated: true do
-        member?(
-          %{
-            __struct__: Date.Range,
-            first_in_iso_days: var!(first_days),
-            last_in_iso_days: var!(last_days)
-          } =
-            var!(date_range),
-          var!(date)
-        )
-      end
-
-    def unquote(member?) do
-      step = if first_days <= last_days, do: 1, else: -1
-      member?(Map.put(date_range, :step, step), date)
-    end
-
-    def count(range) do
-      {:ok, size(range)}
-    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, &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) when remaining > 1 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
-      {: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)}
-    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
-      )
-    end
-
-    defp reduce(_, _, {:cont, acc}, _fun, _step, _calendar) do
-      {:done, acc}
-    end
-
-    defp date_from_iso_days(days, Calendar.ISO) do
-      {year, month, day} = Calendar.ISO.date_from_iso_days(days)
-      %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
-    end
-
-    defp date_from_iso_days(days, calendar) do
-      {year, month, day, _, _, _, _} =
-        calendar.naive_datetime_from_iso_days({days, {0, 86_400_000_000}})
-
-      %Date{year: year, month: month, day: day, calendar: calendar}
-    end
-
-    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: 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
-  end
-
-  defimpl Inspect do
-    import Kernel, except: [inspect: 2]
-
-    def inspect(%Date.Range{first: first, last: last, step: 1}, %Inspect.Opts{}) do
-      "Date.range(" <> inspect(first) <> ", " <> inspect(last) <> ")"
-    end
-
-    def inspect(%Date.Range{first: first, last: last, step: step}, %Inspect.Opts{}) 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)
-    end
-  end
-end

lib/elixir/lib/calendar/duration.ex

@@ -1,600 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-defmodule Duration do
-  @moduledoc """
-  Struct and functions for handling durations.
-
-  A `Duration` struct represents a collection of time scale units,
-  allowing for manipulation and calculation of durations.
-
-  Date and time scale units are represented as integers, allowing for
-  both positive and negative values.
-
-  Microseconds are represented using a tuple `{microsecond, precision}`.
-  This ensures compatibility with other calendar types implementing time,
-  such as `Time`, `DateTime`, and `NaiveDateTime`.
-
-  ## Shifting
-
-  The most common use of durations in Elixir's standard library is to
-  "shift" the calendar types.
-
-      iex> Date.shift(~D[2016-01-03], month: 2)
-      ~D[2016-03-03]
-
-  In the example above, `Date.shift/2` automatically converts the units
-  into a `Duration` struct, although one can also be given directly:
-
-      iex> Date.shift(~D[2016-01-03], Duration.new!(month: 2))
-      ~D[2016-03-03]
-
-  It is important to note that shifting is not an arithmetic operation.
-  For example, adding `date + 1 month + 1 month` does not yield the same
-  result as `date + 2 months`. Let's see an example:
-
-      iex> ~D[2016-01-31] |> Date.shift(month: 1) |> Date.shift(month: 1)
-      ~D[2016-03-29]
-
-      iex> ~D[2016-01-31] |> Date.shift(month: 2)
-      ~D[2016-03-31]
-
-  As you can see above, the results differ, which explains why operations
-  with durations are called "shift" rather than "add". This happens because,
-  once we add one month to `2016-01-31`, we get `2016-02-29`. Then adding
-  one extra month gives us `2016-03-29` instead of `2016-03-31`.
-
-  In particular, when applying durations to `Calendar.ISO` types:
-
-    * larger units (such as years and months) are applied before
-      smaller ones (such as weeks, hours, days, and so on)
-
-    * units are collapsed into months (`:year` and `:month`),
-      seconds (`:week`, `:day`, `:hour`, `:minute`, `:second`)
-      and microseconds (`:microsecond`) before they are applied
-
-    * 1 year is equivalent to 12 months, 1 week is equivalent to 7 days.
-      Therefore, 4 weeks _are not_ equivalent to 1 month
-
-    * in case of non-existing dates, the results are rounded down to the
-      nearest valid date
-
-  As the `shift/2` functions are calendar aware, they are guaranteed to return
-  valid date/times, considering leap years as well as DST in applicable time zones.
-
-  ## Intervals
-
-  Durations in Elixir can be combined with stream operations to build intervals.
-  For example, to retrieve the next three Wednesdays starting from 17th April, 2024:
-
-      iex> ~D[2024-04-17] |> Stream.iterate(&Date.shift(&1, week: 1)) |> Enum.take(3)
-      [~D[2024-04-17], ~D[2024-04-24], ~D[2024-05-01]]
-
-  However, once again, it is important to remember that shifting a duration is not
-  arithmetic, so you may want to use the functions in this module depending on what
-  you want to achieve. Compare the results of both examples below:
-
-      # Adding one month after the other
-      iex> date = ~D[2016-01-31]
-      iex> duration = Duration.new!(month: 1)
-      iex> stream = Stream.iterate(date, fn prev_date -> Date.shift(prev_date, duration) end)
-      iex> Enum.take(stream, 3)
-      [~D[2016-01-31], ~D[2016-02-29], ~D[2016-03-29]]
-
-      # Multiplying durations by an index
-      iex> date = ~D[2016-01-31]
-      iex> duration = Duration.new!(month: 1)
-      iex> stream = Stream.from_index(fn i -> Date.shift(date, Duration.multiply(duration, i)) end)
-      iex> Enum.take(stream, 3)
-      [~D[2016-01-31], ~D[2016-02-29], ~D[2016-03-31]]
-
-  The second example consistently points to the last day of the month,
-  as it performs operations on the duration, rather than shifting date
-  after date.
-
-  ## Comparing durations
-
-  In order to accurately compare durations, you need to either compare
-  only certain fields or use a reference time instant. This is because
-  some fields are relative to others. For example, you may say that
-  1 month is the same as 30 days, but if you add both of these durations
-  to `~D[2015-02-01]`, you would get different results, as that month
-  has only 28 days.
-
-  Therefore, if you wish to compare durations, one option is to use
-  `Date.shift/2` (or `DateTime.shift/2` or similar), and then compare
-  the dates:
-
-      iex> date = ~D[2015-02-01]
-      iex> Date.compare(Date.shift(date, month: 1), Date.shift(date, day: 30))
-      :lt
-
-  Or alternatively convert the durations to a fixed unit by using `to_timeout/1`,
-  which supports durations only up to weeks, raising if it has the month or year
-  fields set.
-
-      iex> to_timeout(hour: 24) == to_timeout(day: 1)
-      true
-  """
-
-  @moduledoc since: "1.17.0"
-
-  @derive {Inspect, optional: [:year, :month, :week, :day, :hour, :minute, :second, :microsecond]}
-  defstruct year: 0,
-            month: 0,
-            week: 0,
-            day: 0,
-            hour: 0,
-            minute: 0,
-            second: 0,
-            microsecond: {0, 0}
-
-  @typedoc """
-  The microsecond component of a duration.
-
-  Unlike `t:Calendar.microsecond/0`, the value may be negative, as
-  durations may represent negative amounts of time. The precision is
-  an integer from 0 to 6 holding the number of significant digits,
-  as in the calendar types.
-  """
-  @type microsecond :: {value :: integer, precision :: 0..6}
-
-  @typedoc """
-  The duration struct type.
-  """
-  @type t :: %Duration{
-          year: integer,
-          month: integer,
-          week: integer,
-          day: integer,
-          hour: integer,
-          minute: integer,
-          second: integer,
-          microsecond: microsecond()
-        }
-
-  @typedoc """
-  The unit pair type specifies a pair of a valid duration unit key and value.
-  """
-  @type unit_pair ::
-          {:year, integer}
-          | {:month, integer}
-          | {:week, integer}
-          | {:day, integer}
-          | {:hour, integer}
-          | {:minute, integer}
-          | {:second, integer}
-          | {:microsecond, microsecond()}
-
-  @typedoc """
-  The duration type specifies a `%Duration{}` struct or a keyword list of valid duration unit pairs.
-  """
-  @type duration :: t | [unit_pair]
-
-  @typedoc """
-  Options for `Duration.to_string/2`.
-  """
-  @type to_string_opts :: [
-          units: [
-            year: String.t(),
-            month: String.t(),
-            week: String.t(),
-            day: String.t(),
-            hour: String.t(),
-            minute: String.t(),
-            second: String.t()
-          ],
-          separator: String.t()
-        ]
-
-  @microseconds_per_second 1_000_000
-
-  @doc """
-  Creates a new `Duration` struct from given `unit_pairs`.
-
-  Raises an `ArgumentError` when called with invalid unit pairs.
-
-  ## Examples
-
-      iex> Duration.new!(year: 1, week: 3, hour: 4, second: 1)
-      %Duration{year: 1, week: 3, hour: 4, second: 1}
-      iex> Duration.new!(second: 1, microsecond: {1000, 6})
-      %Duration{second: 1, microsecond: {1000, 6}}
-      iex> Duration.new!(month: 2)
-      %Duration{month: 2}
-
-  """
-  @spec new!(duration()) :: t
-  def new!(%Duration{} = duration) do
-    duration
-  end
-
-  def new!(unit_pairs) do
-    Enum.each(unit_pairs, &validate_unit!/1)
-    struct!(Duration, unit_pairs)
-  end
-
-  defp validate_unit!({:microsecond, {ms, precision}})
-       when is_integer(ms) and precision in 0..6 do
-    :ok
-  end
-
-  defp validate_unit!({:microsecond, microsecond}) do
-    raise ArgumentError,
-          "unsupported value #{inspect(microsecond)} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6"
-  end
-
-  defp validate_unit!({unit, _value})
-       when unit not in [:year, :month, :week, :day, :hour, :minute, :second] do
-    raise ArgumentError,
-          "unknown unit #{inspect(unit)}. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond"
-  end
-
-  defp validate_unit!({_unit, value}) when is_integer(value) do
-    :ok
-  end
-
-  defp validate_unit!({unit, value}) do
-    raise ArgumentError,
-          "unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer"
-  end
-
-  @doc """
-  Adds units of given durations `d1` and `d2`.
-
-  Respects the highest microsecond precision of the two.
-
-  ## Examples
-
-      iex> Duration.add(Duration.new!(week: 2, day: 1), Duration.new!(day: 2))
-      %Duration{week: 2, day: 3}
-      iex> Duration.add(Duration.new!(microsecond: {400, 3}), Duration.new!(microsecond: {600, 6}))
-      %Duration{microsecond: {1000, 6}}
-
-  """
-  @spec add(t, t) :: t
-  def add(%Duration{microsecond: {ms1, p1}} = d1, %Duration{microsecond: {ms2, p2}} = d2) do
-    %{year: y1, month: mo1, week: w1, day: day1, hour: h1, minute: mi1, second: s1} = d1
-    %{year: y2, month: mo2, week: w2, day: day2, hour: h2, minute: mi2, second: s2} = d2
-
-    %Duration{
-      year: y1 + y2,
-      month: mo1 + mo2,
-      week: w1 + w2,
-      day: day1 + day2,
-      hour: h1 + h2,
-      minute: mi1 + mi2,
-      second: s1 + s2,
-      microsecond: {ms1 + ms2, max(p1, p2)}
-    }
-  end
-
-  @doc """
-  Subtracts units of given durations `d1` and `d2`.
-
-  Respects the highest microsecond precision of the two.
-
-  ## Examples
-
-      iex> Duration.subtract(Duration.new!(week: 2, day: 1), Duration.new!(day: 2))
-      %Duration{week: 2, day: -1}
-      iex> Duration.subtract(Duration.new!(microsecond: {400, 6}), Duration.new!(microsecond: {600, 3}))
-      %Duration{microsecond: {-200, 6}}
-
-  """
-  @spec subtract(t, t) :: t
-  def subtract(%Duration{microsecond: {ms1, p1}} = d1, %Duration{microsecond: {ms2, p2}} = d2) do
-    %{year: y1, month: mo1, week: w1, day: day1, hour: h1, minute: mi1, second: s1} = d1
-    %{year: y2, month: mo2, week: w2, day: day2, hour: h2, minute: mi2, second: s2} = d2
-
-    %Duration{
-      year: y1 - y2,
-      month: mo1 - mo2,
-      week: w1 - w2,
-      day: day1 - day2,
-      hour: h1 - h2,
-      minute: mi1 - mi2,
-      second: s1 - s2,
-      microsecond: {ms1 - ms2, max(p1, p2)}
-    }
-  end
-
-  @doc """
-  Multiplies `duration` units by given `integer`.
-
-  ## Examples
-
-      iex> Duration.multiply(Duration.new!(day: 1, minute: 15, second: -10), 3)
-      %Duration{day: 3, minute: 45, second: -30}
-      iex> Duration.multiply(Duration.new!(microsecond: {200, 4}), 3)
-      %Duration{microsecond: {600, 4}}
-
-  """
-  @spec multiply(t, integer) :: t
-  def multiply(%Duration{microsecond: {ms, p}} = duration, integer) when is_integer(integer) do
-    %{year: y, month: mo, week: w, day: d, hour: h, minute: mi, second: s} = duration
-
-    %Duration{
-      year: y * integer,
-      month: mo * integer,
-      week: w * integer,
-      day: d * integer,
-      hour: h * integer,
-      minute: mi * integer,
-      second: s * integer,
-      microsecond: {ms * integer, p}
-    }
-  end
-
-  @doc """
-  Negates `duration` units.
-
-  ## Examples
-
-      iex> Duration.negate(Duration.new!(day: 1, minute: 15, second: -10))
-      %Duration{day: -1, minute: -15, second: 10}
-      iex> Duration.negate(Duration.new!(microsecond: {500000, 4}))
-      %Duration{microsecond: {-500000, 4}}
-
-  """
-  @spec negate(t) :: t
-  def negate(%Duration{microsecond: {ms, p}} = duration) do
-    %{year: y, month: mo, week: w, day: d, hour: h, minute: mi, second: s} = duration
-
-    %Duration{
-      year: -y,
-      month: -mo,
-      week: -w,
-      day: -d,
-      hour: -h,
-      minute: -mi,
-      second: -s,
-      microsecond: {-ms, p}
-    }
-  end
-
-  @doc """
-  Parses an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) formatted duration string to a `Duration` struct.
-
-  Duration strings, as well as individual units, may be prefixed with plus/minus signs so that:
-
-  - `-PT6H3M` parses as `%Duration{hour: -6, minute: -3}`
-  - `-PT6H-3M` parses as `%Duration{hour: -6, minute: 3}`
-  - `+PT6H3M` parses as `%Duration{hour: 6, minute: 3}`
-  - `+PT6H-3M` parses as `%Duration{hour: 6, minute: -3}`
-
-  Duration designators must be provided in order of magnitude: `P[n]Y[n]M[n]W[n]DT[n]H[n]M[n]S`.
-
-  Only seconds may be specified with a decimal fraction, using either a comma or a full stop: `P1DT4,5S`.
-
-  ## Examples
-
-      iex> Duration.from_iso8601("P1Y2M3DT4H5M6S")
-      {:ok, %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}}
-      iex> Duration.from_iso8601("P3Y-2MT3H")
-      {:ok, %Duration{year: 3, month: -2, hour: 3}}
-      iex> Duration.from_iso8601("-PT10H-30M")
-      {:ok, %Duration{hour: -10, minute: 30}}
-      iex> Duration.from_iso8601("PT4.650S")
-      {:ok, %Duration{second: 4, microsecond: {650000, 3}}}
-
-  """
-  @spec from_iso8601(String.t()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string) when is_binary(string) do
-    case Calendar.ISO.parse_duration(string) do
-      {:ok, duration} ->
-        {:ok, new!(duration)}
-
-      error ->
-        error
-    end
-  end
-
-  @doc """
-  Same as `from_iso8601/1` but raises an `ArgumentError`.
-
-  ## Examples
-
-      iex> Duration.from_iso8601!("P1Y2M3DT4H5M6S")
-      %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}
-      iex> Duration.from_iso8601!("P10D")
-      %Duration{day: 10}
-
-  """
-  @spec from_iso8601!(String.t()) :: t
-  def from_iso8601!(string) when is_binary(string) do
-    case from_iso8601(string) do
-      {:ok, duration} ->
-        duration
-
-      {:error, reason} ->
-        raise ArgumentError, ~s/failed to parse duration "#{string}". reason: #{inspect(reason)}/
-    end
-  end
-
-  @doc """
-  Converts the given `duration` to a human readable representation.
-
-  ## Options
-
-    * `:units` - the units to be used alongside each duration component.
-      The default units follow the ISO 80000-3 standard:
-
-          [
-            year: "a",
-            month: "mo",
-            week: "wk",
-            day: "d",
-            hour: "h",
-            minute: "min",
-            second: "s"
-          ]
-
-    * `:separator` - a string used to separate the distinct components. Defaults to `" "`.
-
-  ## Examples
-
-      iex> Duration.to_string(Duration.new!(second: 30))
-      "30s"
-      iex> Duration.to_string(Duration.new!(day: 40, hour: 12, minute: 42, second: 12))
-      "40d 12h 42min 12s"
-
-  By default, this function uses ISO 80000-3 units, which uses "a" for years.
-  But you can customize all units via the units option:
-
-      iex> Duration.to_string(Duration.new!(year: 3))
-      "3a"
-      iex> Duration.to_string(Duration.new!(year: 3), units: [year: "y"])
-      "3y"
-
-  You may also choose the separator:
-
-      iex> Duration.to_string(Duration.new!(day: 40, hour: 12, minute: 42, second: 12), separator: ", ")
-      "40d, 12h, 42min, 12s"
-
-  A duration without components is rendered as "0s":
-
-      iex> Duration.to_string(Duration.new!([]))
-      "0s"
-
-  Microseconds are rendered as part of seconds with the appropriate precision:
-
-      iex> Duration.to_string(Duration.new!(second: 1, microsecond: {2_200, 3}))
-      "1.002s"
-      iex> Duration.to_string(Duration.new!(second: 1, microsecond: {-1_200_000, 4}))
-      "-0.2000s"
-
-  """
-  @doc since: "1.18.0"
-  @spec to_string(t, to_string_opts) :: String.t()
-  def to_string(%Duration{} = duration, opts \\ []) do
-    units = Keyword.get(opts, :units, [])
-    separator = Keyword.get(opts, :separator, " ")
-
-    case to_string_year(duration, [], units) do
-      [] ->
-        "0" <> Keyword.get(units, :second, "s")
-
-      [part] ->
-        IO.iodata_to_binary(part)
-
-      parts ->
-        parts |> Enum.reduce(&[&1, separator | &2]) |> IO.iodata_to_binary()
-    end
-  end
-
-  defp to_string_part(0, _units, _key, _default, acc),
-    do: acc
-
-  defp to_string_part(x, units, key, default, acc),
-    do: [[Integer.to_string(x) | Keyword.get(units, key, default)] | acc]
-
-  defp to_string_year(%{year: year} = duration, acc, units) do
-    to_string_month(duration, to_string_part(year, units, :year, "a", acc), units)
-  end
-
-  defp to_string_month(%{month: month} = duration, acc, units) do
-    to_string_week(duration, to_string_part(month, units, :month, "mo", acc), units)
-  end
-
-  defp to_string_week(%{week: week} = duration, acc, units) do
-    to_string_day(duration, to_string_part(week, units, :week, "wk", acc), units)
-  end
-
-  defp to_string_day(%{day: day} = duration, acc, units) do
-    to_string_hour(duration, to_string_part(day, units, :day, "d", acc), units)
-  end
-
-  defp to_string_hour(%{hour: hour} = duration, acc, units) do
-    to_string_minute(duration, to_string_part(hour, units, :hour, "h", acc), units)
-  end
-
-  defp to_string_minute(%{minute: minute} = duration, acc, units) do
-    to_string_second(duration, to_string_part(minute, units, :minute, "min", acc), units)
-  end
-
-  defp to_string_second(%{second: 0, microsecond: {0, _}}, acc, _units) do
-    acc
-  end
-
-  defp to_string_second(%{second: s, microsecond: {ms, p}}, acc, units) do
-    [[second_component(s, ms, p) | Keyword.get(units, :second, "s")] | acc]
-  end
-
-  @doc """
-  Converts the given `duration` to an [ISO 8601-2:2019](https://en.wikipedia.org/wiki/ISO_8601) formatted string.
-
-  This function implements the extension of ISO 8601:2019, allowing weeks to appear between months and days: `P3M3W3D`.
-
-  ## Examples
-
-      iex> Duration.to_iso8601(Duration.new!(year: 3))
-      "P3Y"
-      iex> Duration.to_iso8601(Duration.new!(day: 40, hour: 12, minute: 42, second: 12))
-      "P40DT12H42M12S"
-      iex> Duration.to_iso8601(Duration.new!(second: 30))
-      "PT30S"
-
-      iex> Duration.to_iso8601(Duration.new!([]))
-      "PT0S"
-
-      iex> Duration.to_iso8601(Duration.new!(second: 1, microsecond: {2_200, 3}))
-      "PT1.002S"
-      iex> Duration.to_iso8601(Duration.new!(second: 1, microsecond: {-1_200_000, 4}))
-      "PT-0.2000S"
-  """
-
-  @spec to_iso8601(t) :: String.t()
-  def to_iso8601(%Duration{} = duration) do
-    case {to_iso8601_duration_date(duration), to_iso8601_duration_time(duration)} do
-      {[], []} -> "PT0S"
-      {date, time} -> IO.iodata_to_binary([?P, date, time])
-    end
-  end
-
-  defp to_iso8601_duration_date(%{year: 0, month: 0, week: 0, day: 0}) do
-    []
-  end
-
-  defp to_iso8601_duration_date(%{year: year, month: month, week: week, day: day}) do
-    [pair(year, ?Y), pair(month, ?M), pair(week, ?W), pair(day, ?D)]
-  end
-
-  defp to_iso8601_duration_time(%{hour: 0, minute: 0, second: 0, microsecond: {0, _}}) do
-    []
-  end
-
-  defp to_iso8601_duration_time(%{hour: hour, minute: minute} = d) do
-    [?T, pair(hour, ?H), pair(minute, ?M), second_component(d)]
-  end
-
-  defp second_component(%{second: 0, microsecond: {0, _}}) do
-    []
-  end
-
-  defp second_component(%{second: second, microsecond: {ms, p}}) do
-    [second_component(second, ms, p), ?S]
-  end
-
-  defp second_component(second, _ms, 0) do
-    Integer.to_string(second)
-  end
-
-  defp second_component(second, ms, p) do
-    total_ms = second * @microseconds_per_second + ms
-    second = total_ms |> div(@microseconds_per_second) |> abs()
-    ms = total_ms |> rem(@microseconds_per_second) |> abs()
-    sign = if total_ms < 0, do: ?-, else: []
-
-    [
-      sign,
-      Integer.to_string(second),
-      ?.,
-      Calendar.ISO.microseconds_to_iodata(ms, p)
-    ]
-  end
-
-  @compile {:inline, pair: 2}
-  defp pair(0, _key), do: []
-  defp pair(num, key), do: [Integer.to_string(num), key]
-end

lib/elixir/lib/calendar/time_zone_database.ex

@@ -1,102 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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 example, one period could be the summer of 2018 in the `Europe/London` timezone,
-  where summer time/daylight saving time is in effect and lasts from spring to autumn.
-  In 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. For example, 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, such as 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 naive datetime is ambiguous, return a tuple with `:ambiguous`
-  and the two possible periods. The periods in the tuple must be sorted with the
-  first element being the one that begins first.
-
-  When the provided naive datetime is in a gap, such as during the "spring forward" when going
-  from winter time to summer time, return a tuple with `:gap` and two periods with limits
-  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 return a tuple
-  with `:ok` and the `time_zone_period`.
-  """
-  @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 the `Etc/UTC` timezone.
-
-  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,188 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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, 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_unsafe_atom(), arity}
-    else
-      _ -> :error
-    end
-  end
-
-  @doc """
-  Escapes the given identifier.
-  """
-  @spec escape(binary(), char() | nil, :infinity | non_neg_integer, (char() -> iolist() | false)) ::
-          {escaped :: binary(), remaining :: binary()}
-  def escape(binary, char, limit \\ :infinity, fun \\ &escape_map/1)
-      when (is_binary(binary) and ((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::binary, ?\\, char>>, fun)
-  end
-
-  defp escape(<<?#, ?{, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), <<acc::binary, ?\\, ?#, ?{>>, fun)
-  end
-
-  defp escape(<<h::utf8, t::binary>>, char, count, acc, fun) do
-    if value = fun.(h) do
-      value = IO.iodata_to_binary(value)
-      escape(t, char, decrement(count), <<acc::binary, value::binary>>, fun)
-    else
-      escape(t, char, decrement(count), escape_char(h, acc), fun)
-    end
-  end
-
-  defp escape(<<a::4, b::4, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), <<acc::binary, ?\\, ?x, to_hex(a), to_hex(b)>>, fun)
-  end
-
-  defp escape(<<>>, _char, _count, acc, _fun) do
-    {acc, <<>>}
-  end
-
-  defp escape_char(0, acc), do: <<acc::binary, ?\\, ?0>>
-
-  defp escape_char(char, acc)
-       # Some characters that are confusing (zero-width / alternative spaces) are displayed
-       # using their unicode representation:
-       # https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Special-purpose_characters
-
-       # BOM
-       when char == 0xFEFF
-       # Mathematical invisibles
-       when char in 0x2061..0x2064
-       # Bidirectional neutral
-       when char in [0x061C, 0x200E, 0x200F]
-       # Bidirectional general (source of vulnerabilities)
-       when char in 0x202A..0x202E
-       when char in 0x2066..0x2069
-       # Interlinear annotations
-       when char in 0xFFF9..0xFFFC
-       # Zero-width joiners and non-joiners
-       when char in [0x200C, 0x200D, 0x034F]
-       # Non-break space / zero-width space
-       when char in [0x00A0, 0x200B, 0x2060]
-       # Line/paragraph separators
-       when char in [0x2028, 0x2029]
-       # Spaces
-       when char in 0x2000..0x200A
-       when char == 0x205F do
-    <<a::4, b::4, c::4, d::4>> = <<char::16>>
-    <<acc::binary, ?\\, ?u, to_hex(a), to_hex(b), to_hex(c), to_hex(d)>>
-  end
-
-  defp escape_char(char, acc)
-       when char in 0x20..0x7E
-       when char in 0xA0..0xD7FF
-       when char in 0xE000..0xFFFD
-       when char in 0x10000..0x10FFFF do
-    <<acc::binary, char::utf8>>
-  end
-
-  defp escape_char(char, acc) when char < 0x80 do
-    <<a::4, b::4>> = <<char::8>>
-    <<acc::binary, ?\\, ?x, to_hex(a), to_hex(b)>>
-  end
-
-  defp escape_char(char, acc) when char < 0x10000 do
-    <<a::4, b::4, c::4, d::4>> = <<char::16>>
-    <<acc::binary, ?\\, ?u, to_hex(a), to_hex(b), to_hex(c), to_hex(d)>>
-  end
-
-  defp escape_char(char, acc) when char < 0x1000000 do
-    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
-
-    <<acc::binary, ?\\, ?u, ?{, 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,635 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-
-defmodule Code.Normalizer do
-  @moduledoc false
-
-  @do_end_keywords [:rescue, :catch, :else, :after]
-
-  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.
-  """
-  @spec normalize(Macro.t(), keyword()) :: Macro.t()
-  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, state.escape)
-  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 = normalize_bitstring(string, state, state.escape)
-    {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta, [string, utf8]}
-  end
-
-  # Charlists with interpolations
-  # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed
-  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)
-
-      parts = maybe_add_trailing_newline(call_meta, parts, state)
-      {{:., 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
-
-  # The right hand side is an atom in the AST but it's not an atom literal, so
-  # it should not be wrapped. However, it should be escaped if applicable.
-  defp do_normalize({:., meta, [left, right]}, state) when is_atom(right) do
-    meta = patch_meta_line(meta, state.parent_meta)
-
-    left = do_normalize(left, %{state | parent_meta: meta})
-    right = maybe_escape_literal(right, state)
-
-    {:., meta, [left, right]}
-  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]}]
-
-        args ->
-          normalize_map_args(args, state)
-      end
-
-    {:%{}, meta, args}
-  end
-
-  # Sigils
-  defp do_normalize({sigil, meta, [{:<<>>, _, args} = string, modifiers]} = quoted, state)
-       when is_atom(sigil) and is_list(args) and is_list(modifiers) do
-    with "sigil_" <> _ <- Atom.to_string(sigil),
-         true <- binary_interpolated?(args),
-         true <- List.ascii_printable?(modifiers) do
-      meta =
-        meta
-        |> patch_meta_line(state.parent_meta)
-        |> Keyword.put_new(:delimiter, "\"")
-
-      string = normalize_bitstring(string, %{state | parent_meta: meta}, false)
-      {sigil, meta, [string, modifiers]}
-    else
-      _ ->
-        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_unsafe_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, we normalize it as a ~C sigil
-      string =
-        if state.escape do
-          {iolist, _} = Code.Identifier.escape(IO.chardata_to_string(list), nil)
-          IO.iodata_to_binary(iolist)
-        else
-          List.to_string(list)
-        end
-
-      meta = patch_meta_line([delimiter: "\""], state.parent_meta)
-
-      {:sigil_c, meta, [{:<<>>, [], [string]}, []]}
-    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
-
-    last = List.last(args)
-
-    cond do
-      not allow_keyword?(form, arity) ->
-        args = normalize_args(args, %{state | parent_meta: meta})
-        {form, meta, args}
-
-      Keyword.has_key?(meta, :do) and kw_blocks?(last) ->
-        # def foo do :ok end
-        # def foo, do: :ok
-        normalize_kw_blocks(form, meta, args, state)
-
-      match?([{:do, _} | _], last) and kw_blocks?(last) ->
-        # Non normalized kw blocks
-        line = state.parent_meta[:line] || meta[:line]
-        meta = meta ++ [do: [line: line], end: [line: line]]
-        normalize_kw_blocks(form, meta, args, state)
-
-      true ->
-        # The formatter renders do-end blocks from the meta alone
-        meta = Keyword.drop(meta, [:do, :end])
-        args = normalize_args(args, %{state | parent_meta: meta})
-        {last_arg, leading_args} = List.pop_at(args, -1, [])
-
-        last_args =
-          case last_arg do
-            {:__block__, _meta, [[{{:__block__, key_meta, _}, _} | _] = keyword]} ->
-              cond do
-                key_meta[:format] == :keyword ->
-                  [keyword]
-
-                block_keyword?(keyword) ->
-                  [
-                    Enum.map(keyword, fn {{:__block__, meta, args}, value} ->
-                      {{:__block__, [format: :keyword] ++ meta, args}, value}
-                    end)
-                  ]
-
-                true ->
-                  [last_arg]
-              end
-
-            [] ->
-              []
-
-            _ ->
-              [last_arg]
-          end
-
-        {form, meta, leading_args ++ last_args}
-    end
-  end
-
-  defp block_keyword?([{{:__block__, _, [key]}, _val} | tail]) when is_atom(key),
-    do: block_keyword?(tail)
-
-  defp block_keyword?([]), do: true
-  defp block_keyword?(_), do: false
-
-  # Anything after the do block that is not a block keyword makes it a keyword list
-  defp kw_blocks?([{:do, _} | rest] = kw) do
-    Keyword.keyword?(kw) and Enum.all?(rest, &match?({key, _} when key in @do_end_keywords, &1))
-  end
-
-  defp kw_blocks?([{{:__block__, _, [:do]}, _} | rest]) do
-    Enum.all?(rest, &match?({{:__block__, _, [key]}, _} when key in @do_end_keywords, &1))
-  end
-
-  defp kw_blocks?(_), do: false
-
-  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) 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
-
-    parts = maybe_add_trailing_newline(meta, parts, state)
-    {:<<>>, meta, parts}
-  end
-
-  defp maybe_add_trailing_newline(meta, parts, state) do
-    with true <- state.escape and Keyword.get(meta, :delimiter) in ["\"\"\"", "'''"],
-         last = List.last(parts),
-         true <- is_binary(last) and not String.ends_with?(last, "\n") do
-      [_last | rest] = Enum.reverse(parts)
-      Enum.reverse([last <> "\n" | rest])
-    else
-      _ -> parts
-    end
-  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_unsafe_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
-      ~c"Elixir." ++ _ -> false
-      _ -> keyword?(rest)
-    end
-  end
-
-  defp keyword?([]), do: true
-  defp keyword?(_other), do: false
-end

lib/elixir/lib/code/typespec.ex

@@ -1,432 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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, :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`, `:opaque` and, on Erlang/OTP 28+,
-  `:nominal`).
-
-  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, :nominal] do
-            cond do
-              kind == :opaque -> {:opaque, type}
-              kind == :nominal -> {:nominal, 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 specs will be in the Erlang
-  Abstract Format.
-  """
-  @spec fetch_specs(module | binary) :: {: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 the callback name and arity and the second is the callback.
-
-  The module must have a corresponding BEAM file
-  which can be located by the runtime system. The callbacks will be
-  in the Erlang Abstract Format.
-  """
-  @spec fetch_callbacks(module | binary) :: {: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),
-         info_pairs when is_list(info_pairs) <- :beam_lib.info(beam),
-         {:ok, ^module} <- Keyword.fetch(info_pairs, :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, [_var, type]}) do
-    collect_vars(type)
-  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
-    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, :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}) when op in [:+, :-] do
-    {op, meta(anno), [typespec_to_quoted(arg)]}
-  end
-
-  defp typespec_to_quoted({:op, anno, :*, arg1, arg2}) do
-    {:*, meta(anno), [typespec_to_quoted(arg1), typespec_to_quoted(arg2)]}
-  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_unsafe_atom("_#{String.downcase(<<c::utf8>>)}#{rest}")
-
-      <<c::utf8, rest::binary>> ->
-        String.to_unsafe_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
-    case :erl_anno.location(anno) do
-      {line, column} ->
-        [line: line, column: column]
-
-      line when is_integer(line) ->
-        [line: line]
-    end
-  end
-end

lib/elixir/lib/collectable.ex

@@ -1,7 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defprotocol Collectable do
   @moduledoc """
   A protocol to traverse data structures.
@@ -17,195 +13,85 @@ defprotocol Collectable do
   The `Enumerable` protocol is useful to take values out of a collection.
   In order to support a wide range of values, the functions provided by
   the `Enumerable` protocol do not keep shape. For example, passing a
-  map to `Enum.map/2` always returns a list.
+  dictionary to `Enum.map/2` always returns a list.
 
   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. It provides two functions: `into/1` and `empty/1`.
 
-  ## Examples
-
-  To show how to manually use the `Collectable` protocol, let's play with a
-  simplified 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])
-
-  To show how the protocol can be implemented, we can again look at the
-  simplified 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
-          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
-          end
-
-          initial_acc = map_set
-
-          {initial_acc, 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])
-
-  ## Halting
-
-  The `:halt` flag will be given whenever the collection won't
-  terminate correctly and must be used to clean up existing resources
-  (such as sockets, file handles, etc).
-
-  Note it is not guaranteed that the accumulator given to halt will
-  be the latest version of the accumulator returned by a previous call
-  with `{:cont, elem}`. Therefore, you must track the collected results
-  within the resource you intend to halt.
-
-  This is by design: ensuring halt is always called with the latest
-  accumulator would make pure collectables (the ones that do not implement
-  halt) expensive. However, given the collectables that must implement halt
-  already need to track state, the burden of tracking the accumulator
-  across invocations is put on them.
+  `into/1` can be seen as the opposite of `Enumerable.reduce/3`. If
+  `Enumerable` is about taking values out, `Collectable.into/1` is about
+  collecting those values into a structure.
   """
 
   @type command :: {:cont, term} | :done | :halt
 
   @doc """
-  Returns an initial accumulator and a "collector" function.
-
-  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.
-
-  `:done` is passed as a command when no further values will be injected. This
-  is useful when there's a need to close resources or normalizing values. A
-  collectable must be returned when the command is `:done`.
-
-  If injection is suddenly interrupted, `:halt` is passed and the function
-  can return any value as it won't be used.
-
-  For examples on how to use the `Collectable` protocol and `into/1` see the
-  module documentation.
+  Receives a collectable structure and returns an empty one.
   """
-  @spec into(t) :: {initial_acc :: term, collector :: (term, command -> t | term)}
+  @spec empty(t) :: t
+  def empty(collectable)
+
+  @doc """
+  Returns a function that collects values alongside
+  the initial accumulation value.
+
+  The returned function receives a collectable and injects a given
+  value into it for every `{:cont, term}` instruction.
+
+  `:done` is passed when no further values will be injected, useful
+  for closing resources and normalizing values. A collectable must
+  be returned on `:done`.
+
+  If injection is suddenly interrupted, `:halt` is passed and it can
+  return any value, as it won't be used.
+  """
+  @spec into(t) :: {term, (term, command -> t | term)}
   def into(collectable)
 end
 
 defimpl Collectable, for: List do
-  def into(list) do
-    # TODO: Change the behavior 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 behavior 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
+  def empty(_list) do
+    []
+  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
-
-      _acc, {:cont, other} ->
-        raise ArgumentError,
-              "collecting into a binary requires a bitstring, got: #{inspect(other)}"
-    end
-
-    {[binary], fun}
+  def empty(_bitstring) do
+    ""
   end
 
-  def into(bitstring) do
-    fun = fn
-      acc, {:cont, x} when is_bitstring(x) ->
-        <<acc::bitstring, x::bitstring>>
-
-      acc, :done ->
-        acc
-
-      _acc, :halt ->
-        :ok
-
-      _acc, {:cont, other} ->
-        raise ArgumentError,
-              "collecting into a bitstring requires a bitstring, got: #{inspect(other)}"
-    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)
+  def empty(_map) do
+    %{}
+  end
 
-      map_acc, :done ->
-        map_acc
-
-      _map_acc, :halt ->
-        :ok
-
-      _map_acc, {:cont, other} ->
-        raise ArgumentError,
-              "collecting into a map requires {key, value} tuples, got: #{inspect(other)}"
-    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,406 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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.
-
-  > #### Avoid application environment in libraries {: .info}
-  >
-  > 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, see ["Using application configuration for
-  > libraries"](design-anti-patterns.md#using-application-configuration-for-libraries).
-
-  ## Migrating from `use Mix.Config`
-
-  The `Config` module in Elixir was introduced in v1.9 as a replacement to
-  `use Mix.Config`, which was specific to Mix and has been deprecated.
-
-  You can leverage `Config` instead of `use 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 places where you may access functions from the `Mix` module are
-  the `mix.exs` file and inside custom Mix tasks, which are 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`).
-  """
-
-  @type config_opts :: [
-          imports: [Path.t()] | :disabled,
-          env: atom(),
-          target: atom()
-        ]
-
-  @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,
-
-      config :logger,
-        level: :info,
-        truncate: 1024
-
-  will have a final configuration for `:logger` of:
-
-      [level: :info, truncate: 1024]
-
-  """
-  @doc since: "1.9.0"
-  @spec config(atom(), keyword()) :: keyword()
-  def config(root_key, opts) when is_atom(root_key) and is_list(opts) do
-    if not 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"
-  @spec config(atom(), atom(), term()) :: keyword()
-  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 """
-  Reads the configuration for the given root key.
-
-  This function only reads the configuration from a previous
-  `config/2` or `config/3` call. If `root_key` points to an
-  application, it does not read its actual application environment.
-  Its main use case is to make it easier to access and share
-  configuration values across files.
-
-  If the `root_key` was not configured, it returns `nil`.
-
-  ## Examples
-
-      # In config/config.exs
-      config :my_app, foo: :bar
-
-      # In config/dev.exs
-      config :another_app, foo: read_config(:my_app)[:foo] || raise "missing parent configuration"
-
-  """
-  @doc since: "1.18.0"
-  @spec read_config(atom()) :: keyword() | nil
-  def read_config(root_key) when is_atom(root_key) do
-    get_config!()[root_key]
-  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, returns the `MIX_ENV` specified when running `mix release`.
-
-  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 the file is relative, it will be expanded relative to the
-  directory of the current configuration file.
-
-  ## 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(), config_opts) :: {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) when is_list(config) do
-    Enum.each(config, fn
-      {app, value} when is_atom(app) ->
-        if not Keyword.keyword?(value) do
-          raise ArgumentError,
-                "expected config for app #{inspect(app)} in #{Path.relative_to_cwd(file)} " <>
-                  "to return keyword list, got: #{inspect(value)}"
-        end
-
-      other ->
-        raise ArgumentError,
-              "expected config in #{Path.relative_to_cwd(file)} to be a keyword list " <>
-                "of {atom, keyword} pairs, got entry: #{inspect(other)}"
-    end)
-
-    config
-  end
-
-  defp validate!(config, file) do
-    raise ArgumentError,
-          "expected config in #{Path.relative_to_cwd(file)} to be a keyword list " <>
-            "of {atom, keyword} pairs, got: #{inspect(config)}"
-  end
-end

lib/elixir/lib/config/provider.ex

@@ -1,449 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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()
-
-  @typedoc """
-  Options for `init/3`.
-  """
-  @type init_opts :: [
-          extra_config: config(),
-          prune_runtime_sys_config_after_boot: boolean(),
-          reboot_system_after_config: boolean(),
-          validate_compile_env: [{atom(), [atom()], term()}]
-        ]
-
-  @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
-  @spec init([{module(), term()}], config_path(), init_opts()) :: config()
-  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,
-         {:error, message} <- validate_compile_env(compile_env) do
-      abort(message)
-    end
-  end
-
-  @doc false
-  def valid_compile_env?(compile_env) do
-    Enum.all?(compile_env, fn {app, [key | path], compile_return} ->
-      try do
-        traverse_env(Application.fetch_env(app, key), path) == compile_return
-      rescue
-        _ -> false
-      end
-    end)
-  end
-
-  @doc false
-  def validate_compile_env(compile_env, ensure_loaded? \\ true)
-
-  def validate_compile_env([{app, [key | path], compile_return} | compile_env], ensure_loaded?) do
-    if ensure_app_loaded?(app, ensure_loaded?) do
-      try do
-        traverse_env(Application.fetch_env(app, key), path)
-      rescue
-        e ->
-          {:error,
-           """
-           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 ->
-          validate_compile_env(compile_env, ensure_loaded?)
-
-        runtime_return ->
-          {:error,
-           """
-           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 behavior than expected:
-
-             * Compile time value #{return_to_text(compile_return)}
-             * Runtime value #{return_to_text(runtime_return)}
-
-           #{compile_env_tips(app)}
-           """}
-      end
-    else
-      validate_compile_env(compile_env, ensure_loaded?)
-    end
-  end
-
-  def validate_compile_env([], _ensure_loaded?) do
-    :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.clean #{app} --build"
-
-      * 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,148 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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
-
-  @type config_opts :: [
-          imports: [Path.t()] | :disabled,
-          env: atom(),
-          target: atom()
-        ]
-
-  @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, config_opts) :: 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(), config_opts) :: 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(), config_opts) :: {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,39 +1,139 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule Dict do
   @moduledoc ~S"""
-  Generic API for dictionaries.
+  This module specifies the Dict API expected to be
+  implemented by different dictionaries. It also provides
+  functions that redirect to the underlying Dict, allowing
+  a developer to work with different Dict implementations
+  using one API.
 
-  If you need a general dictionary, use the `Map` module.
-  If you need to manipulate keyword lists, use `Keyword`.
+  To create a new dict, use the `new` functions defined
+  by each dict type:
+
+      HashDict.new  #=> creates an empty HashDict
+
+  In the examples below, `dict_impl` means a specific
+  `Dict` implementation, for example `HashDict` or `Map`.
+
+  ## Protocols
+
+  Besides implementing the functions in this module, all
+  dictionaries are required to implement the `Access`
+  protocol:
+
+      iex> dict = dict_impl.new
+      iex> dict = Dict.put(dict, :hello, :world)
+      iex> dict[:hello]
+      :world
+
+  As well as the `Enumerable` and `Collectable` protocols.
+
+  ## Match
+
+  Dictionaries are required to implement all operations
+  using the match (`===`) operator.
+
+  ## Default implementation
+
+  Default implementations for some functions in the `Dict` module
+  are provided via `use Dict`.
+
+  For example:
+
+      defmodule MyDict do
+        use Dict
+
+        # implement required functions (see below)
+        # override default implementations if optimization
+        # is needed
+      end
+
+  The client module must contain the following functions:
+
+    * `delete/2`
+    * `fetch/2`
+    * `put/3`
+    * `reduce/3`
+    * `size/1`
+
+  All functions, except `reduce/3`, are required by the Dict behaviour.
+  `reduce/3` must be implemtented as per the Enumerable protocol.
+
+  Based on these functions, `Dict` generates default implementations
+  for the following functions:
+
+    * `drop/2`
+    * `equal?/2`
+    * `fetch!/2`
+    * `get/2`
+    * `get/3`
+    * `has_key?/2`
+    * `keys/1`
+    * `merge/2`
+    * `merge/3`
+    * `pop/2`
+    * `pop/3`
+    * `put_new/3`
+    * `split/2`
+    * `take/2`
+    * `to_list/1`
+    * `update/4`
+    * `update!/3`
+    * `values/1`
+
+  All of these functions are defined as overridable, so you can provide
+  your own implementation if needed.
+
+  Note you can also test your custom module via `Dict`'s doctests:
+
+      defmodule MyDict do
+        # ...
+      end
+
+      defmodule MyTests do
+        use ExUnit.Case
+        doctest Dict
+        defp dict_impl, do: MyDict
+      end
 
-  To convert maps into keywords and vice-versa, use the
-  `new` function in the respective modules.
   """
 
-  @moduledoc deprecated: "Use Map or Keyword modules instead"
+  use Behaviour
 
   @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"
+  defcallback new :: t
+  defcallback delete(t, key) :: t
+  defcallback drop(t, Enum.t) :: t
+  defcallback equal?(t, t) :: boolean
+  defcallback get(t, key) :: value
+  defcallback get(t, key, value) :: value
+  defcallback fetch(t, key) :: {:ok, value} | :error
+  defcallback fetch!(t, key) :: value | no_return
+  defcallback has_key?(t, key) :: boolean
+  defcallback keys(t) :: [key]
+  defcallback merge(t, t) :: t
+  defcallback merge(t, t, (key, value, value -> value)) :: t
+  defcallback pop(t, key) :: {value, t}
+  defcallback pop(t, key, value) :: {value, t}
+  defcallback put(t, key, value) :: t
+  defcallback put_new(t, key, value) :: t
+  defcallback size(t) :: non_neg_integer()
+  defcallback split(t, Enum.t) :: {t, t}
+  defcallback take(t, Enum.t) :: t
+  defcallback to_list(t) :: list()
+  defcallback update(t, key, value, (value -> value)) :: t
+  defcallback update!(t, key, (value -> value)) :: t | no_return
+  defcallback values(t) :: list(value)
 
   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"
+      @behaviour Dict
 
-      @deprecated message
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -41,22 +141,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
-          :error -> fun.()
-        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
@@ -64,35 +148,23 @@ 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
-          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 ->
+        Enum.reduce(keys, new, fn key, acc ->
           case fetch(dict, key) do
             {:ok, value} -> put(acc, key, value)
             :error -> acc
@@ -100,49 +172,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]
 
@@ -154,263 +218,444 @@ 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 ->
+        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
     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
+  @doc """
+  Returns a list of all keys in `dict`.
+  The keys are not guaranteed to be in any order.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> Enum.sort(Dict.keys(dict))
+      [:a,:b]
+
+  """
   @spec keys(t) :: [key]
   def keys(dict) do
     target(dict).keys(dict)
   end
 
-  @deprecated message
+  @doc """
+  Returns a list of all values in `dict`.
+  The values are not guaranteed to be in any order.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> Enum.sort(Dict.values(dict))
+      [1,2]
+
+  """
   @spec values(t) :: [value]
   def values(dict) do
     target(dict).values(dict)
   end
 
-  @deprecated message
+  @doc """
+  Returns the number of elements in `dict`.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> Dict.size(dict)
+      2
+
+  """
   @spec size(t) :: non_neg_integer
   def size(dict) do
     target(dict).size(dict)
   end
 
-  @deprecated message
+  @doc """
+  Returns whether the given `key` exists in the given `dict`.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.has_key?(dict, :a)
+      true
+      iex> Dict.has_key?(dict, :b)
+      false
+
+  """
   @spec has_key?(t, key) :: boolean
   def has_key?(dict, key) do
     target(dict).has_key?(dict, key)
   end
 
-  @deprecated message
+  @doc """
+  Returns the value associated with `key` in `dict`. If `dict` does not
+  contain `key`, returns `default` (or `nil` if not provided).
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.get(dict, :a)
+      1
+      iex> Dict.get(dict, :b)
+      nil
+      iex> Dict.get(dict, :b, 3)
+      3
+  """
   @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
+  @doc """
+  Returns `{:ok, value}` associated with `key` in `dict`.
+  If `dict` does not contain `key`, returns `:error`.
 
-  @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
+  ## Examples
 
-  @deprecated message
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.fetch(dict, :a)
+      {:ok, 1}
+      iex> Dict.fetch(dict, :b)
+      :error
+
+  """
   @spec fetch(t, key) :: value
   def fetch(dict, key) do
     target(dict).fetch(dict, key)
   end
 
-  @deprecated message
-  @spec fetch!(t, key) :: value
+  @doc """
+  Returns the value associated with `key` in `dict`. If `dict` does not
+  contain `key`, it raises `KeyError`.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.fetch!(dict, :a)
+      1
+
+  """
+  @spec fetch!(t, key) :: value | no_return
   def fetch!(dict, key) do
     target(dict).fetch!(dict, key)
   end
 
-  @deprecated message
+  @doc """
+  Stores the given `value` under `key` in `dict`.
+  If `dict` already has `key`, the stored value is replaced by the new one.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.put(dict, :a, 3)
+      iex> Dict.get(dict, :a)
+      3
+
+  """
   @spec put(t, key, value) :: t
   def put(dict, key, val) do
     target(dict).put(dict, key, val)
   end
 
-  @deprecated message
+  @doc """
+  Puts the given `value` under `key` in `dict` unless `key` already exists.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.put_new(dict, :a, 3)
+      iex> Dict.get(dict, :a)
+      1
+
+  """
   @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
+  @doc """
+  Removes the entry stored under the given `key` from `dict`.
+  If `dict` does not contain `key`, returns the dictionary unchanged.
 
-  @deprecated message
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.delete(dict, :a)
+      iex> Dict.get(dict, :a)
+      nil
+
+      iex> dict = Enum.into([b: 2], dict_impl.new)
+      iex> Dict.delete(dict, :a) == dict
+      true
+
+  """
   @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)
-    target2 = target(dict2)
+  @doc """
+  Merges the dict `dict2` into dict `dict1`.
 
-    if target1 == target2 do
-      target1.merge(dict1, dict2)
-    else
-      do_merge(target1, dict1, dict2, fn _k, _v1, v2 -> v2 end)
-    end
-  end
+  If one of the `dict2` entries already exists in `dict1`, the
+  functions in entries in `dict2` have higher precedence unless a
+  function is given to resolve conflicts.
 
-  @deprecated message
+  Notice this function is polymorphic as it merges dicts of any
+  type. Each dict implementation also provides a `merge` function,
+  but they can only merge dicts of the same type.
+
+  ## Examples
+
+      iex> dict1 = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict2 = Enum.into([a: 3, d: 4], dict_impl.new)
+      iex> dict = Dict.merge(dict1, dict2)
+      iex> [a: Dict.get(dict, :a), b: Dict.get(dict, :b), d: Dict.get(dict, :d)]
+      [a: 3, b: 2, d: 4]
+
+      iex> dict1 = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict2 = Enum.into([a: 3, d: 4], dict_impl.new)
+      iex> dict = Dict.merge(dict1, dict2, fn(_k, v1, v2) ->
+      ...>   v1 + v2
+      ...> end)
+      iex> [a: Dict.get(dict, :a), b: Dict.get(dict, :b), d: Dict.get(dict, :d)]
+      [a: 4, b: 2, d: 4]
+
+  """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(dict1, dict2, fun) do
+  def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
     target1 = target(dict1)
     target2 = target(dict2)
 
     if target1 == target2 do
       target1.merge(dict1, dict2, fun)
     else
-      do_merge(target1, dict1, dict2, fun)
+      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
   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)
-  end
+  @doc """
+  Returns the value associated with `key` in `dict` as
+  well as the `dict` without `key`.
 
-  @deprecated message
+  ## Examples
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> {v, dict} = Dict.pop dict, :a
+      iex> {v, Enum.sort(dict)}
+      {1,[]}
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> {v, dict} = Dict.pop dict, :b
+      iex> {v, Enum.sort(dict)}
+      {nil,[a: 1]}
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> {v, dict} = Dict.pop dict, :b, 3
+      iex> {v, Enum.sort(dict)}
+      {3,[a: 1]}
+
+  """
   @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
+  @doc """
+  Update a value in `dict` by calling `fun` on the value to get a new
+  value. An exception is generated if `key` is not present in the dict.
 
-  @deprecated message
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.update!(dict, :a, fn(val) -> -val end)
+      iex> Dict.get(dict, :a)
+      -1
+
+  """
   @spec update!(t, key, (value -> value)) :: t
   def update!(dict, key, fun) do
     target(dict).update!(dict, key, fun)
   end
 
-  @deprecated message
+  @doc """
+  Update a value in `dict` by calling `fun` on the value to get a new value. If
+  `key` is not present in `dict` then `initial` will be stored as the first
+  value.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.update(dict, :c, 3, fn(val) -> -val end)
+      iex> Dict.get(dict, :c)
+      3
+
+  """
   @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
+  @doc """
+  Returns a tuple of two dicts, where the first dict contains only
+  entries from `dict` with keys in `keys`, and the second dict
+  contains only entries from `dict` with keys not in `keys`
+
+  Any non-member keys are ignored.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2, c: 3, d: 4], dict_impl.new)
+      iex> {dict1, dict2} = Dict.split(dict, [:a, :c, :e])
+      iex> {Dict.to_list(dict1) |> Enum.sort, Dict.to_list(dict2) |> Enum.sort}
+      {[a: 1, c: 3], [b: 2, d: 4]}
+
+      iex> dict = Enum.into([], dict_impl.new)
+      iex> {dict1, dict2} = Dict.split(dict, [:a, :c])
+      iex> {Dict.to_list(dict1), Dict.to_list(dict2)}
+      {[], []}
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> {dict1, dict2} = Dict.split(dict, [:a, :b, :c])
+      iex> {Dict.to_list(dict1) |> Enum.sort, Dict.to_list(dict2)}
+      {[a: 1, b: 2], []}
+
+  """
   @spec split(t, [key]) :: {t, t}
   def split(dict, keys) do
     target(dict).split(dict, keys)
   end
 
-  @deprecated message
+  @doc """
+  Returns a new dict where the given `keys` are removed from `dict`.
+  Any non-member keys are ignored.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.drop(dict, [:a, :c, :d])
+      iex> Dict.to_list(dict)
+      [b: 2]
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.drop(dict, [:c, :d])
+      iex> Dict.to_list(dict) |> Enum.sort
+      [a: 1, b: 2]
+
+  """
   @spec drop(t, [key]) :: t
   def drop(dict, keys) do
     target(dict).drop(dict, keys)
   end
 
-  @deprecated message
+  @doc """
+  Returns a new dict where only the keys in `keys` from `dict` are included.
+
+  Any non-member keys are ignored.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.take(dict, [:a, :c, :d])
+      iex> Dict.to_list(dict)
+      [a: 1]
+      iex> dict = Dict.take(dict, [:c, :d])
+      iex> Dict.to_list(dict)
+      []
+
+  """
   @spec take(t, [key]) :: t
   def take(dict, keys) do
     target(dict).take(dict, keys)
   end
 
-  @deprecated message
+  @doc false
   @spec empty(t) :: t
   def empty(dict) do
     target(dict).empty(dict)
   end
 
-  @deprecated message
+  @doc """
+  Check if two dicts are equal using `===`.
+
+  Notice this function is polymorphic as it compares dicts of any
+  type. Each dict implementation also provides an `equal?` function,
+  but they can only compare dicts of the same type.
+
+  ## Examples
+
+      iex> dict1 = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
+      iex> dict2 = [a: 2, b: 3, f: 5, c: 123]
+      iex> Dict.equal?(dict1, dict2)
+      true
+
+      iex> dict1 = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
+      iex> dict2 = []
+      iex> Dict.equal?(dict1, dict2)
+      false
+
+  """
   @spec equal?(t, t) :: boolean
   def equal?(dict1, dict2) do
     target1 = target(dict1)
@@ -421,27 +666,28 @@ 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
+  @doc """
+  Returns a list of key-value pairs stored in `dict`.
+  No particular order is enforced.
+  """
   @spec to_list(t) :: list
   def to_list(dict) do
     target(dict).to_list(dict)
   end
 
-  @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

@@ -1,22 +1,18 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 require Record
 
 defmodule File.Stat do
   @moduledoc """
-  A struct that holds file information.
+  A struct responsible to hold file information.
 
   In Erlang, this struct is represented by a `:file_info` record.
   Therefore this module also provides functions for converting
-  between the Erlang record and the Elixir struct.
+  in between the Erlang record and the Elixir struct.
 
   Its fields are:
 
     * `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
@@ -27,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.
@@ -36,53 +32,36 @@ defmodule File.Stat do
       systems which have no concept of links.
 
     * `major_device` - identifies the file system where the file is located.
-      In Windows, the number indicates a drive as follows: 0 means A:, 1 means
+      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
-      systems.
+    * `uid` - indicates the owner of the file.
 
-    * `gid` - indicates the group that owns the file. Will be zero for
-      non-Unix-like file systems.
+    * `gid` - gives the group that the owner of the file belongs to. Will be
+      zero for 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`,
-  `:universal`, or `:posix`. Default is `:universal`.
+  `:universal`, or `:posix`. Default is `:local`.
   """
 
   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() | :undefined,
-          type: :device | :directory | :regular | :other | :symlink | :undefined,
-          access: :read | :write | :read_write | :none | :undefined,
-          atime: :calendar.datetime() | integer() | :undefined,
-          mtime: :calendar.datetime() | integer() | :undefined,
-          ctime: :calendar.datetime() | integer() | :undefined,
-          mode: non_neg_integer() | :undefined,
-          links: non_neg_integer() | :undefined,
-          major_device: non_neg_integer() | :undefined,
-          minor_device: non_neg_integer() | :undefined,
-          inode: non_neg_integer() | :undefined,
-          uid: non_neg_integer() | :undefined,
-          gid: non_neg_integer() | :undefined
-        }
+  @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
@@ -90,9 +69,6 @@ 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

@@ -1,7 +1,3 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 defmodule File.Stream do
   @moduledoc """
   Defines a `File.Stream` struct returned by `File.stream!/3`.
@@ -11,67 +7,45 @@ 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
-    * `node`          - the node the file belongs to
+    * `line_or_bytes` - if reading should read lines or a given amount of bytes
 
   """
 
-  defstruct path: nil, modes: [], line_or_bytes: :line, raw: true, node: nil
+  defstruct path: nil, modes: [], line_or_bytes: :line, raw: true
 
-  @type t :: %__MODULE__{
-          path: Path.t(),
-          modes: [term()],
-          line_or_bytes: :line | pos_integer(),
-          raw: boolean(),
-          node: node()
-        }
+  @type t :: %__MODULE__{}
 
   @doc false
-  def __build__(path, line_or_bytes, modes) do
-    with {:read_offset, offset} <- :lists.keyfind(:read_offset, 1, modes),
-         false <- is_integer(offset) and offset >= 0 do
-      raise ArgumentError,
-            "expected :read_offset to be a non-negative integer, got: #{inspect(offset)}"
-    end
-
+  def __build__(path, modes, line_or_bytes) do
     raw = :lists.keyfind(:encoding, 1, modes) == false
 
     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]
-          end
-
-        false ->
-          modes
+      if raw do
+        if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
+          [:raw|modes]
+        else
+          [:raw, :read_ahead|modes]
+        end
+      else
+        modes
       end
 
-    %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes, node: node()}
-  end
-
-  @doc false
-  def __open__(%File.Stream{path: path, node: node}, modes) when node == node() do
-    :file.open(path, modes)
-  end
-
-  @doc false
-  def __open__(%File.Stream{path: path, node: node}, modes) do
-    :erpc.call(node, :file_io_server, :start, [self(), path, List.delete(modes, :raw)])
+    %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes}
   end
 
   defimpl Collectable do
-    def into(%{modes: modes, raw: raw} = stream) do
-      modes = for mode <- modes, mode not in [:read], do: mode
+    def empty(stream) do
+      stream
+    end
 
-      case File.Stream.__open__(stream, [:write | modes]) do
+    def into(%{path: path, modes: modes, raw: raw} = stream) do
+      modes = for mode <- modes, not mode in [:read], do: mode
+
+      case :file.open(path, [:write|modes]) do
         {:ok, device} ->
           {:ok, into(device, stream, raw)}
-
         {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: stream.path
+          raise File.Error, reason: reason, action: "stream", path: path
       end
     end
 
@@ -79,16 +53,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.
@@ -98,56 +70,27 @@ defmodule File.Stream do
   end
 
   defimpl Enumerable do
-    @read_ahead_size 64 * 1024
+    def reduce(%{path: path, modes: modes, line_or_bytes: line_or_bytes, raw: raw}, acc, fun) do
+      modes = for mode <- modes, not mode in [:write, :append], do: mode
 
-    def reduce(%{modes: modes, line_or_bytes: line_or_bytes, raw: raw} = stream, acc, fun) do
-      start_fun = fn ->
-        case File.Stream.__open__(stream, read_modes(modes)) do
-          {:ok, device} ->
-            skip_bom_and_offset(device, raw, modes)
-
-          {:error, reason} ->
-            raise File.Error, reason: reason, action: "stream", path: stream.path
+      start_fun =
+        fn ->
+          case :file.open(path, modes) do
+            {:ok, device}    -> device
+            {:error, reason} ->
+              raise File.Error, reason: reason, action: "stream", path: path
+          end
         end
-      end
 
       next_fun =
         case raw do
-          true -> &IO.each_binstream(&1, line_or_bytes)
+          true  -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
 
       Stream.resource(start_fun, next_fun, &:file.close/1).(acc, fun)
     end
 
-    def count(%{modes: modes, line_or_bytes: :line, path: path, raw: raw} = stream) do
-      pattern = :binary.compile_pattern("\n")
-
-      counter = fn device ->
-        device = skip_bom_and_offset(device, raw, modes)
-        count_lines(device, path, pattern, read_function(stream), 0, :empty)
-      end
-
-      {:ok, open!(stream, modes, counter)}
-    end
-
-    def count(%{path: path, line_or_bytes: bytes, raw: true, modes: modes, node: node} = stream) do
-      case :erpc.call(node, File, :stat, [path]) do
-        {:ok, %{size: 0}} ->
-          {:error, __MODULE__}
-
-        {:ok, %{size: size}} ->
-          bom_offset = count_raw_bom(stream, modes)
-          offset = get_read_offset(modes)
-          size = max(size - bom_offset - offset, 0)
-          remainder = if rem(size, bytes) == 0, do: 0, else: 1
-          {:ok, div(size, bytes) + remainder}
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
     def count(_stream) do
       {:error, __MODULE__}
     end
@@ -155,109 +98,5 @@ defmodule File.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
-
-    def slice(_stream) do
-      {:error, __MODULE__}
-    end
-
-    defp open!(stream, modes, fun) do
-      case File.Stream.__open__(stream, read_modes(modes)) do
-        {:ok, device} ->
-          try do
-            fun.(device)
-          after
-            :file.close(device)
-          end
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: stream.path
-      end
-    end
-
-    defp count_raw_bom(stream, modes) do
-      if :trim_bom in modes do
-        open!(stream, read_modes(modes), &(&1 |> trim_bom(true) |> elem(1)))
-      else
-        0
-      end
-    end
-
-    defp skip_bom_and_offset(device, raw, modes) do
-      device =
-        if :trim_bom in modes do
-          device |> trim_bom(raw) |> elem(0)
-        else
-          device
-        end
-
-      offset = get_read_offset(modes)
-
-      if offset > 0 do
-        {:ok, _} = :file.position(device, {:cur, offset})
-      end
-
-      device
-    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
-
-    def get_read_offset(modes) do
-      case :lists.keyfind(:read_offset, 1, modes) do
-        {:read_offset, offset} -> offset
-        false -> 0
-      end
-    end
-
-    defp read_modes(modes) do
-      for mode <- modes, mode not in [:write, :append, :trim_bom], do: mode
-    end
-
-    defp count_lines(device, path, pattern, read, count, last_byte) do
-      case read.(device) do
-        data when is_binary(data) and byte_size(data) > 0 ->
-          newlines = length(:binary.matches(data, pattern))
-          last = :binary.last(data)
-          count_lines(device, path, pattern, read, count + newlines, last)
-
-        data when is_binary(data) ->
-          count_lines(device, path, pattern, read, count, last_byte)
-
-        :eof ->
-          case last_byte do
-            :empty -> 0
-            ?\n -> count
-            _ -> count + 1
-          end
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    defp read_function(%{raw: true}), do: &IO.binread(&1, @read_ahead_size)
-    defp read_function(%{raw: false}), do: &IO.read(&1, @read_ahead_size)
   end
 end

lib/elixir/lib/float.ex

@@ -1,715 +1,276 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
 import Kernel, except: [round: 1]
 
 defmodule Float do
   @moduledoc """
-  Functions for working with floating-point numbers.
-
-  For mathematical operations on top of floating-points,
-  see Erlang's [`:math`](`:math`) module.
-
-  ## 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](https://0.30000000000000004.com/)
-    * [What Every Programmer Should Know About Floating-Point Arithmetic](https://floating-point-gui.de/)
-
+  Functions for working with floating point numbers.
   """
 
-  import Bitwise
-
-  @power_of_2_to_52 4_503_599_627_370_496
-  @precision_range 0..15
-  @type precision_range :: 0..15
-
-  @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
-
-  """
-  @spec max_finite() :: float
-  def max_finite, do: @max_finite
-
-  @doc """
-  Returns the minimum finite value for a float.
-
-  ## Examples
-
-      iex> Float.min_finite()
-      -1.7976931348623157e308
-
-  """
-  @spec min_finite() :: float
-  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.
 
-  If successful, returns a tuple in the form of `{float, remainder_of_binary}`;
-  when the binary cannot be coerced into a valid float, the atom `:error` is
-  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.
-
-  If you want to convert a string-formatted float directly to a float,
-  `String.to_float/1` can be used instead.
+  If successful, returns a tuple of the form `{float, remainder_of_binary}`.
+  Otherwise `:error`.
 
   ## Examples
 
       iex> Float.parse("34")
-      {34.0, ""}
+      {34.0,""}
+
       iex> Float.parse("34.25")
-      {34.25, ""}
+      {34.25,""}
+
       iex> Float.parse("56.5xyz")
-      {56.5, "xyz"}
+      {56.5,"xyz"}
 
-      iex> Float.parse(".12")
-      :error
       iex> Float.parse("pi")
       :error
-      iex> Float.parse("1.7976931348623159e+308")
-      :error
 
   """
   @spec parse(binary) :: {float, binary} | :error
   def parse("-" <> binary) do
-    case parse_unsigned(binary) do
+    case parse_unsign(binary) do
       :error -> :error
       {number, remainder} -> {-number, remainder}
     end
   end
 
-  def parse("+" <> binary) do
-    parse_unsigned(binary)
-  end
-
   def parse(binary) do
-    parse_unsigned(binary)
+    parse_unsign(binary)
   end
 
-  defp parse_unsigned(<<digit, rest::binary>> = binary) when digit in ?0..?9,
-    do: parse_mantissa(binary, rest, false)
-
-  defp parse_unsigned(binary) when is_binary(binary), do: :error
-
-  defp parse_mantissa(binary, <<digit, rest::binary>>, dot?) when digit in ?0..?9,
-    do: parse_mantissa(binary, rest, dot?)
-
-  defp parse_mantissa(binary, <<?., digit, rest::binary>>, false) when digit in ?0..?9,
-    do: parse_mantissa(binary, rest, true)
-
-  defp parse_mantissa(binary, <<exp_marker, digit, rest::binary>> = tail, dot?)
-       when exp_marker in ~c"eE" and digit in ?0..?9,
-       do: parse_exponent(binary, byte_size(binary) - byte_size(tail), rest, dot?)
-
-  defp parse_mantissa(binary, <<exp_marker, sign, digit, rest::binary>> = tail, dot?)
-       when exp_marker in ~c"eE" and sign in ~c"-+" and digit in ?0..?9,
-       do: parse_exponent(binary, byte_size(binary) - byte_size(tail), rest, dot?)
-
-  defp parse_mantissa(binary, rest, dot?), do: finish_mantissa(binary, rest, dot?)
-
-  defp parse_exponent(binary, exp_pos, <<digit, rest::binary>>, dot?) when digit in ?0..?9,
-    do: parse_exponent(binary, exp_pos, rest, dot?)
-
-  defp parse_exponent(binary, exp_pos, rest, dot?),
-    do: finish_exponent(binary, exp_pos, rest, dot?)
-
-  defp finish_mantissa(binary, rest, _dot? = true) do
-    {:erlang.binary_to_float(consumed(binary, rest)), rest}
-  rescue
-    ArgumentError -> :error
+  defp parse_unsign("-" <> _), do: :error
+  defp parse_unsign(binary) when is_binary(binary) do
+    case Integer.parse binary do
+      :error -> :error
+      {integer_part, after_integer} -> parse_unsign after_integer, integer_part
+    end
   end
 
-  # Bare integer: * 1.0 casts to the nearest float without building a new binary,
-  # and raises ArithmeticError on overflow (for example a 400-digit integer).
-  defp finish_mantissa(binary, rest, _dot? = false) do
-    {:erlang.binary_to_integer(consumed(binary, rest)) * 1.0, rest}
-  rescue
-    ArithmeticError -> :error
+  # Dot followed by digit is required afterwards or we are done
+  defp parse_unsign(<< ?., char, rest :: binary >>, int) when char in ?0..?9 do
+    parse_unsign(rest, char - ?0, 1, int)
   end
 
-  # binary_to_float/1 raises ArgumentError when the exponent is too big, e.g. "1.0e400".
-  defp finish_exponent(binary, _exp_pos, rest, _dot? = true) do
-    {:erlang.binary_to_float(consumed(binary, rest)), rest}
-  rescue
-    ArgumentError -> :error
+  defp parse_unsign(rest, int) do
+    {:erlang.float(int), rest}
   end
 
-  # No decimal point, so ".0" is spliced in before the exponent (at exp_pos) to
-  # form a valid float literal.
-  defp finish_exponent(binary, exp_pos, rest, _dot? = false) do
-    len = byte_size(binary) - byte_size(rest)
-
-    literal =
-      IO.iodata_to_binary([
-        :binary.part(binary, 0, exp_pos),
-        ".0",
-        :binary.part(binary, exp_pos, len - exp_pos)
-      ])
-
-    {:erlang.binary_to_float(literal), rest}
-  rescue
-    ArgumentError -> :error
+  # Handle decimal points
+  defp parse_unsign(<< char, rest :: binary >>, float, decimal, int) when char in ?0..?9 do
+    parse_unsign rest, 10 * float + (char - ?0), decimal + 1, int
   end
 
-  defp consumed(binary, ""), do: binary
-  defp consumed(binary, rest), do: :binary.part(binary, 0, byte_size(binary) - byte_size(rest))
+  defp parse_unsign(<< ?e, after_e :: binary >>, float, decimal, int) do
+    case Integer.parse after_e do
+      :error ->
+        # Note we rebuild the binary here instead of breaking it apart at
+        # the function clause because the current approach copies a binary
+        # just on this branch. If we broke it apart in the function clause,
+        # the copy would happen when calling Integer.parse/1.
+        {floatify(int, float, decimal), << ?e, after_e :: binary >>}
+      {exponential, after_exponential} ->
+        {floatify(int, float, decimal, exponential), after_exponential}
+    end
+  end
+
+  defp parse_unsign(bitstring, float, decimal, int) do
+    {floatify(int, float, decimal), bitstring}
+  end
+
+  defp floatify(int, float, decimal, exponential \\ 0) do
+    multiplier = if int < 0, do: -1.0, else: 1.0
+
+    # Try to ensure the minimum amount of rounding errors
+    result = multiplier * (abs(int) * :math.pow(10, decimal) + float) * :math.pow(10, exponential - decimal)
+
+    # Try avoiding stuff like this:
+    # iex(1)> 0.0001 * 75
+    # 0.007500000000000001
+    # Due to IEEE 754 floating point standard
+    # http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+
+    final_decimal_places = decimal - exponential
+    if final_decimal_places > 0 do
+      decimal_power_round = :math.pow(10,  final_decimal_places)
+      trunc(result * decimal_power_round) / decimal_power_round
+    else
+      result
+    end
+  end
 
   @doc """
-  Rounds a float to the largest float less than or equal to `number`.
+  Rounds a float to the largest integer less than or equal to `num`.
 
-  `floor/2` also accepts a precision to round a floating-point value down
+  Floor 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
+  This function always returns floats. One may use `Kernel.trunc/1` to
   truncate the result to an integer afterwards.
 
-  ## Known issues
-
-  The behavior of `floor/2` for floats can be surprising. For example:
-
-      iex> Float.floor(12.52, 2)
-      12.51
-
-  One may have expected it to floor to 12.52. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as 12.51999999,
-  which explains the behavior above.
-
   ## Examples
 
       iex> Float.floor(34.25)
       34.0
+
       iex> Float.floor(-56.5)
       -57.0
-      iex> Float.floor(34.259, 2)
+
+      iex> Float.floor(34.253, 2)
       34.25
 
   """
-  @spec floor(float, precision_range) :: float
-  def floor(number, precision \\ 0)
-
-  def floor(number, 0) when is_float(number) do
-    :math.floor(number)
-  end
-
-  def floor(number, precision) when is_float(number) and precision in @precision_range do
-    round(number, precision, :floor)
-  end
-
-  def floor(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
+  @spec floor(float, 0..15) :: float
+  def floor(number, precision \\ 0) when is_float(number) and precision in 0..15 do
+    power     = power_of_10(precision)
+    number    = number * power
+    truncated = trunc(number)
+    variance  = if number - truncated < 0, do: -1.0, else: 0.0
+    (truncated + variance) / power
   end
 
   @doc """
-  Rounds a float to the smallest float greater than or equal to `number`.
+  Rounds a float to the largest integer greater than or equal to `num`.
 
-  `ceil/2` also accepts a precision to round a floating-point value up
-  to an arbitrary number of fractional digits (between 0 and 15).
+  Ceil 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.
-
-  The behavior of `ceil/2` for floats can be surprising. For example:
-
-      iex> Float.ceil(-12.52, 2)
-      -12.51
-
-  One may have expected it to ceil to -12.52. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as -12.51999999,
-  which explains the behavior above.
-
-  This function always returns floats. `Kernel.trunc/1` may be used instead to
+  This function always returns floats. One may use `Kernel.trunc/1` to
   truncate the result to an integer afterwards.
 
   ## Examples
 
       iex> Float.ceil(34.25)
       35.0
+
       iex> Float.ceil(-56.5)
       -56.0
-      iex> Float.ceil(34.251, 2)
+
+      iex> Float.ceil(34.253, 2)
       34.26
-      iex> Float.ceil(-0.01)
-      -0.0
 
   """
-  @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
-
-  def ceil(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
+  @spec ceil(float, 0..15) :: float
+  def ceil(number, precision \\ 0) when is_float(number) and precision in 0..15 do
+    power     = power_of_10(precision)
+    number    = number * power
+    truncated = trunc(number)
+    variance  = if number - truncated > 0, do: 1.0, else: 0.0
+    (truncated + variance) / power
   end
 
   @doc """
-  Rounds a floating-point value to an arbitrary number of fractional
-  digits (between 0 and 15).
+  Rounds a floating point value to an arbitrary number of fractional digits
+  (between 0 and 15).
 
-  The rounding direction always ties to half up. The operation is
-  performed on the binary floating point, without a conversion to decimal.
-
-  This function only accepts floats and always returns a float. Use
-  `Kernel.round/1` if you want a function that accepts both floats
-  and integers and always returns an integer.
-
-  ## Known issues
-
-  The behavior of `round/2` for floats can be surprising. For example:
-
-      iex> Float.round(5.5675, 3)
-      5.567
-
-  One may have expected it to round to the half up 5.568. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as 5.567499999,
-  which explains the behavior above. If you want exact rounding for decimals,
-  you must use a decimal library. The behavior above is also in accordance
-  with reference implementations, such as "Correctly Rounded Binary-Decimal and
-  Decimal-Binary Conversions" by David M. Gay.
+  This function only accepts floats and returns floats. Use `Kernel.round/1`
+  if you want a function that accepts both floats and integers and always
+  returns an integer.
 
   ## Examples
 
-      iex> Float.round(12.5)
-      13.0
       iex> Float.round(5.5674, 3)
       5.567
+
       iex> Float.round(5.5675, 3)
-      5.567
+      5.568
+
       iex> Float.round(-5.5674, 3)
       -5.567
-      iex> Float.round(-5.5675)
-      -6.0
-      iex> Float.round(12.341444444444441, 15)
-      12.341444444444441
-      iex> Float.round(-0.01)
-      -0.0
+
+      iex> Float.round(-5.5675, 3)
+      -5.568
 
   """
-  @spec round(float, precision_range) :: float
-  def round(float, precision \\ 0)
-
-  def round(float, 0) when float === 0.0 or float === -0.0, do: float
-
-  def round(float, 0) when is_float(float) do
-    case :erlang.round(float) * 1.0 do
-      zero when zero == 0.0 and float < 0.0 -> -0.0
-      rounded -> rounded
-    end
-  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
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
-  # Decimal-place rounding via exact rational scaling. This is the bignum
-  # core used by reference implementations like David M. Gay's "Correctly
-  # Rounded Binary-Decimal and Decimal-Binary Conversions" (cited in the
-  # @doc above), Python's round(), and Java's BigDecimal.setScale.
-  #
-  # 1. Decompose float exactly: |float| = mantissa / 2^shift.
-  # 2. Scale exactly: |float| * 10^precision = mantissa * 10^precision / 2^shift.
-  #    Because precision is bounded to 0..15, the product fits in ~103 bits
-  #    (53-bit mantissa + ~50-bit power of ten) and BEAM bignums handle it
-  #    directly without approximation.
-  # 3. Round the exact rational to an integer per the requested mode
-  #    (half_up / floor / ceil) using quotient and remainder.
-  # 4. Emit the float closest to rounded_int / 10^precision:
-  #    - fast path: when rounded_int < 2^53, both operands are exactly
-  #      representable as floats and IEEE division is correctly rounded.
-  #    - slow path: bignum alignment + manual mantissa extraction with
-  #      round-to-nearest-even for the trailing bit.
-  #
-  # The integer-rounding decision (step 3) and the binary-emission decision
-  # (step 4) are deliberately independent: step 3 picks the exact rational
-  # the user asked for, step 4 picks the closest float to that rational.
-  # Conflating them is the classic source of double-rounding bugs.
-  #
-  # Faster algorithms exist (Cox 2026's table-based uscale; Ryū / Schubfach
-  # for round-trip printing) but target different problems or assume
-  # fixed-width machine arithmetic that BEAM doesn't expose efficiently.
-  # At precision <= 15, the exact path is small, easy to audit, and fast
-  # enough that a more complex algorithm has not been justified by benchmarks.
-  defp round(num, _precision, _rounding) when is_float(num) and num == 0.0, do: num
-
-  defp round(float, precision, mode) do
-    <<sign::1, exp::11, mantissa::52>> = <<float::float>>
-
-    cond do
-      # Subnormal — tiny but non-zero; treat per-mode (ceil(+) and floor(-) bump
-      # to 10^-precision; everything else rounds to signed zero).
-      exp == 0 ->
-        tiny_round(sign, precision, mode)
-
-      # |float| >= 2^52 — has no fractional bits, return unchanged.
-      exp - 1075 >= 0 ->
-        float
-
-      true ->
-        mantissa = @power_of_2_to_52 ||| mantissa
-        shift = 1075 - exp
-        do_round(sign, mantissa, shift, precision, mode)
-    end
-  end
-
-  # |float * 10^precision| < 0.5 — integer round is 0; ceil/floor still bump per sign.
-  defp do_round(sign, _mantissa, shift, precision, mode) when shift >= 104 do
-    tiny_round(sign, precision, mode)
-  end
-
-  defp do_round(sign, mantissa, shift, precision, mode) do
+  @spec round(float, 0..15) :: float
+  def round(number, precision \\ 0) when is_float(number) and precision in 0..15 do
     power = power_of_10(precision)
-    product = mantissa * power
-    half = 1 <<< (shift - 1)
-    quotient = product >>> shift
-    remainder = product - (quotient <<< shift)
-    rounded_int = round_step(mode, sign, quotient, remainder, half)
-
-    cond do
-      rounded_int == 0 ->
-        signed_zero(sign)
-
-      rounded_int < @power_of_2_to_52 <<< 1 ->
-        # Both rounded_int and power fit in 53 bits, so IEEE float division
-        # is correctly rounded.
-        result = rounded_int / power
-        if sign == 1, do: -result, else: result
-
-      true ->
-        bignum_to_float(sign, rounded_int, power)
-    end
+    Kernel.round(number * power) / power
   end
 
-  defp round_step(:half_up, _sign, quotient, remainder, half) do
-    if remainder >= half, do: quotient + 1, else: quotient
-  end
-
-  defp round_step(:floor, 0, quotient, _remainder, _half), do: quotient
-  defp round_step(:floor, 1, quotient, remainder, _half) when remainder > 0, do: quotient + 1
-  defp round_step(:floor, 1, quotient, _remainder, _half), do: quotient
-
-  defp round_step(:ceil, 0, quotient, remainder, _half) when remainder > 0, do: quotient + 1
-  defp round_step(:ceil, 0, quotient, _remainder, _half), do: quotient
-  defp round_step(:ceil, 1, quotient, _remainder, _half), do: quotient
-
-  defp signed_zero(0), do: 0.0
-  defp signed_zero(1), do: -0.0
-
-  # Result of rounding a non-zero float whose |float * 10^precision| < 0.5.
-  # ceil(+) → +10^-precision, floor(-) → -10^-precision, others → signed 0.
-  defp tiny_round(0, precision, :ceil), do: 1.0 / power_of_10(precision)
-  defp tiny_round(1, precision, :floor), do: -1.0 / power_of_10(precision)
-  defp tiny_round(sign, _precision, _mode), do: signed_zero(sign)
-
-  # Slow path: emit float closest to `sign * rounded_int / power` when
-  # rounded_int >= 2^53. The binary emission step is always IEEE
-  # round-to-nearest-even, regardless of the integer-rounding mode.
-  defp bignum_to_float(sign, rounded_int, power) do
-    shift_adjust = bit_length(rounded_int) - bit_length(power) - 53
-    {numerator, denominator, exp} = align(rounded_int, power, shift_adjust)
-
-    quotient = div(numerator, denominator)
-    remainder = numerator - quotient * denominator
-    half = denominator >>> 1
-
-    mantissa =
-      cond do
-        remainder > half -> quotient + 1
-        remainder < half -> quotient
-        (quotient &&& 1) === 1 -> quotient + 1
-        true -> quotient
-      end
-
-    # Carry-bit normalization: `mantissa` lives in [2^52, 2^53]. The upper
-    # bound `2^53` is reachable when `align/3` returns an upper-bound quotient
-    # or when rounding carries. Rebalance into the canonical [2^52, 2^53)
-    # range so the 52-bit packing below doesn't silently truncate.
-    {mantissa, exp} =
-      if mantissa == @power_of_2_to_52 <<< 1,
-        do: {@power_of_2_to_52, exp + 1},
-        else: {mantissa, exp}
-
-    <<result::float>> = <<sign::1, exp + 1023::11, mantissa - @power_of_2_to_52::52>>
-    result
-  end
-
-  # Pick (numerator, denominator, exp) so that numerator/denominator ∈ [2^52, 2^53)
-  # and the resulting float = numerator/denominator * 2^(exp-52).
-  defp align(rounded_int, power, shift_adjust) when shift_adjust >= 0 do
-    new_power = power <<< shift_adjust
-
-    if rounded_int < new_power <<< 53,
-      do: {rounded_int, new_power, 52 + shift_adjust},
-      else: {rounded_int, new_power <<< 1, 53 + shift_adjust}
-  end
-
-  defp align(rounded_int, power, shift_adjust) do
-    shifted = rounded_int <<< -shift_adjust
-
-    cond do
-      shifted >= power <<< 53 -> {shifted, power <<< 1, 53 + shift_adjust}
-      shifted >= power <<< 52 -> {shifted, power, 52 + shift_adjust}
-      true -> {shifted <<< 1, power, 51 + shift_adjust}
-    end
-  end
-
-  defp bit_length(0), do: 0
-  defp bit_length(integer) when integer > 0, do: bit_length(integer, 0)
-  defp bit_length(integer, acc) when integer >= 1 <<< 64, do: bit_length(integer >>> 64, acc + 64)
-  defp bit_length(integer, acc) when integer >= 1 <<< 16, do: bit_length(integer >>> 16, acc + 16)
-  defp bit_length(integer, acc) when integer >= 1 <<< 4, do: bit_length(integer >>> 4, acc + 4)
-  defp bit_length(integer, acc) when integer >= 1, do: bit_length(integer >>> 1, acc + 1)
-  defp bit_length(_integer, acc), do: acc
-
-  Enum.reduce(0..15, 1, fn exponent, acc ->
-    defp power_of_10(unquote(exponent)), do: unquote(acc)
+  Enum.reduce 0..15, 1, fn x, acc ->
+    defp power_of_10(unquote(x)), do: unquote(acc)
     acc * 10
-  end)
-
-  @doc """
-  Returns a pair of integers whose ratio is exactly equal
-  to the original float and with a positive denominator.
-
-  ## Examples
-
-      iex> Float.ratio(0.0)
-      {0, 1}
-      iex> Float.ratio(3.14)
-      {7070651414971679, 2251799813685248}
-      iex> Float.ratio(-3.14)
-      {-7070651414971679, 2251799813685248}
-      iex> Float.ratio(1.5)
-      {3, 2}
-      iex> Float.ratio(-1.5)
-      {-3, 2}
-      iex> Float.ratio(16.0)
-      {16, 1}
-      iex> Float.ratio(-16.0)
-      {-16, 1}
-
-  """
-  @doc since: "1.4.0"
-  @spec ratio(float) :: {integer, pos_integer}
-  def ratio(float) when is_float(float) and float == 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}
-    end
   end
 
-  defp root_factors(mantissa, count) when mantissa != 0 and (mantissa &&& 1) == 0,
-    do: root_factors(mantissa >>> 1, count + 1)
-
-  defp root_factors(mantissa, count),
-    do: {mantissa, count}
-
-  @compile {:inline, sign: 2}
-  defp sign(0, num), do: num
-  defp sign(1, num), do: -num
-
   @doc """
-  Returns a charlist which corresponds to the shortest text representation
-  of the given float.
-
-  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 a configurable representation, use `:erlang.float_to_list/2`.
+  Returns a char list which corresponds to the text representation of the given float.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Float.to_charlist(7.0)
-      ~c"7.0"
+      iex> Float.to_char_list(7.0)
+      '7.00000000000000000000e+00'
 
   """
-  @spec to_charlist(float) :: charlist
-  def to_charlist(float) do
-    :erlang.float_to_list(float, [:short])
+  @spec to_char_list(float) :: char_list
+  def to_char_list(number) do
+    :erlang.float_to_list(number)
   end
 
   @doc """
-  Returns a binary which corresponds to the shortest text representation
-  of the given float.
+  Returns a list which corresponds to the text representation
+  of `float`.
 
-  The underlying algorithm changes depending on the Erlang/OTP version:
+  ## Options
 
-    * 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.
+    * `:decimals`   — number of decimal points to show
+    * `:scientific` — number of decimal points to show, in scientific format
+    * `:compact`    — when true, use the most compact representation (ignored
+                      with the `scientific` option)
 
-    * 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.
+  ## Examples
 
-  For a configurable representation, use `:erlang.float_to_binary/2`.
+      iex> Float.to_char_list 7.1, [decimals: 2, compact: true]
+      '7.1'
+
+  """
+  @spec to_char_list(float, list) :: char_list
+  def to_char_list(float, options) do
+    :erlang.float_to_list(float, expand_compact(options))
+  end
+
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `some_float`.
 
   Inlined by the compiler.
 
   ## Examples
 
       iex> Float.to_string(7.0)
-      "7.0"
+      "7.00000000000000000000e+00"
 
   """
-  @spec to_string(float) :: String.t()
-  def to_string(float) do
-    :erlang.float_to_binary(float, [:short])
+  @spec to_string(float) :: String.t
+  def to_string(some_float) do
+    :erlang.float_to_binary(some_float)
   end
 
-  @doc false
-  @deprecated "Use Float.to_charlist/1 instead"
-  def to_char_list(float), do: Float.to_charlist(float)
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `float`.
 
-  @doc false
-  @deprecated "Use :erlang.float_to_list/2 instead"
-  def to_char_list(float, options) do
-    :erlang.float_to_list(float, expand_compact(options))
-  end
+  ## Options
 
-  @doc false
-  @deprecated "Use :erlang.float_to_binary/2 instead"
+    * `:decimals`   — number of decimal points to show
+    * `:scientific` — number of decimal points to show, in scientific format
+    * `:compact`    — when true, use the most compact representation (ignored
+                      with the `scientific` option)
+
+  ## Examples
+
+      iex> Float.to_string 7.1, [decimals: 2, compact: true]
+      "7.1"
+
+  """
+  @spec to_string(float, list) :: String.t
   def to_string(float, options) do
     :erlang.float_to_binary(float, expand_compact(options))
   end
 
-  defp invalid_precision_message(precision) do
-    "precision #{inspect(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, 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: []
 end

lib/elixir/lib/function.ex

@@ -1,207 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-# SPDX-FileCopyrightText: 2021 The Elixir Team
-# SPDX-FileCopyrightText: 2012 Plataformatec
-
-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
-          | :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:
-
-    * `: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`, and `:uniq`.
-  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}
-
-  """
-  @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> ~c"abcdaabccc" |> Enum.sort() |> Enum.chunk_by(&Function.identity/1)
-      [~c"aaa", ~c"bb", ~c"cccc", ~c"d"]
-
-      iex> Enum.group_by(~c"abracadabra", &Function.identity/1)
-      %{97 => ~c"aaaaa", 98 => ~c"bb", 99 => ~c"c", 100 => ~c"d", 114 => ~c"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